I worked at Infosys on India’s first GST e-invoicing system. Spring Boot was the backbone of that backend. Millions of invoices, strict government compliance requirements, zero tolerance for downtime. It held up fine. That’s more or less when I stopped questioning whether this framework was worth learning.

This series is for people who want to actually understand Spring Boot, not just get it running and move on.

Spring Framework is not Spring Boot

This trips up a lot of beginners, so let’s get it out of the way first.

Spring Framework is a toolkit for building Java applications. It has been around since 2003 and is modular by design. You use what you need and ignore the rest.

The main modules:

• Web — handles incoming HTTP requests, processes them, returns a response (HTML for a browser, JSON for an API)

• Data — abstracts away the repetitive parts of working with databases, whether that’s SQL or something in-memory

• AOP (Aspect-Oriented Programming) — lets you attach cross-cutting concerns like logging and security to your application without scattering that logic everywhere

• Core — dependency injection and object lifecycle management. This is the thing that makes Spring, Spring.

• Test — utilities for testing Spring components

Each module has a specific job. That’s the design philosophy and it works.

Spring Boot is a layer that sits on top of Spring Framework. It exists because setting up a raw Spring project involved a tedious amount of configuration that was almost identical every single time. Someone eventually decided that was silly, and Spring Boot was the result.

It gives you an embedded server, pre-wired dependencies, and a project structure that works out of the box. You spend less time on setup and more time on the actual problem.

Spring Framework gives you the parts. Spring Boot gives you the parts already assembled.

The Ecosystem

Spring Boot is one project in a larger family. Worth knowing what else is out there:

• Spring Boot — removes setup friction. Your starting point.

• Spring Framework — the core toolkit. Everything else builds on this.

• Spring Data — cleaner database access

• Spring Security — authentication and authorization

• Spring Batch — large-scale batch processing

• Spring Integration — messaging and system-to-system communication

• Spring Cloud — microservices and distributed systems

You do not need most of this right now. It is just useful to have a mental map so you know what to reach for later.

What This Series Covers

We are going to build a backend store application from the ground up. Each part introduces one concept and builds on the previous one. No jumping ahead.

• Part 1 (this one) — What Spring and Spring Boot are, and how they relate

• Part 2 — Project setup and understanding what every file actually does

• Part 3 — Your first REST API endpoint

• Part 4 — Database access with Spring Data

• Part 5 — Validation, error handling, and not embarrassing yourself with your API design

• Part 6 — Security with Spring Security

More parts after that depending on where the series goes.

Who This Is For

You know basic Java. You have heard of Spring but the official documentation made your eyes glaze over. You want to understand the why, not just copy code that works for reasons you cannot explain.

If that is not you, this probably is not for you.

Part 2 covers project setup. See you there.

Steve

I have been using IntelliJ full time for years. Enterprise Java, large codebases, the kind of projects where you spend more time reading code than writing it. Over that time you stop caring about features that look cool and start caring about the ones that make you faster.

These are those ones. Some are obvious. Some most people never find. All of them are worth knowing.

1. Breakpoint Groups (hidden gem)

Open the Breakpoints dialog: Windows: Ctrl + Shift + F8 Mac: Cmd + Shift + F8

Most people scatter breakpoints across a codebase and then forget which ones belong to what. IntelliJ lets you group breakpoints and give each group a name. The way I use this: whenever I pick up a Jira ticket, I create a group named after the ticket number — say, PROJ-1042 — and add every breakpoint I set for that ticket to that group.

When you are done with the ticket, uncheck the group. All those breakpoints get disabled in one click without deleting them. When the ticket comes back for rework, you just re-enable the group and everything is exactly where you left it. No hunting through files trying to remember where you were debugging.

To create a group, right-click any breakpoint in the Breakpoints dialog and select Move to Group. Name it after the ticket number. It takes ten seconds to set up and saves a lot of confusion on longer tickets.

2. Search Everywhere

Windows: Shift Shift Mac: Shift Shift

Double tap Shift and a search box opens that finds literally anything — classes, files, symbols, actions, settings. If you are still using the file tree to navigate, stop. This is faster for everything.

3. Find Action (hidden gem)

Windows: Ctrl + Shift + A Mac: Cmd + Shift + A

Can’t remember a shortcut? Search for any action by name and run it directly. This is also how you discover features you didn’t know existed. Type “column selection” or “wrap with” and see what comes up.

4. Recent Files

Windows: Ctrl + E Mac: Cmd + E

Opens a popup of your recently accessed files. You can also start typing to filter. Faster than any tab management strategy you currently have.

5. Navigate to Last Edit Location (hidden gem)

Windows: Ctrl + Shift + Backspace Mac: Cmd + Shift + Backspace

Jumps you back to the exact line you last edited. Useful when you are reading code across multiple files and need to get back to where you were working. Most people do not know this exists.

6. Multiple Cursors (hidden gem)

Windows: Alt + Click Mac: Alt + Click

Click in multiple places while holding Alt and you get a cursor at each location. Edit all of them simultaneously. Useful for renaming repetitive patterns that a refactor tool would overcomplicate.

7. Select Next Occurrence

Windows: Alt + J Mac: Ctrl + G

Select a word, then keep pressing this shortcut to select the next occurrence of it in the file. Each one gets its own cursor. Edit all of them at once. Faster than find and replace for simple cases.

8. Expand and Shrink Selection

Windows: Ctrl + W / Ctrl + Shift + W Mac: Alt + Up / Alt + Down

Expands or shrinks your selection by syntax scope — word, expression, statement, block, method, class. Much more precise than dragging. Use it when you need to copy a whole expression without counting brackets.

9. Matching Brace Navigation

Windows: Ctrl + Shift + M Mac: Ctrl + M

Jumps your cursor between the opening and closing brace of a block. Useful in deeply nested code when you want to quickly check where a block ends without scrolling.

10. Navigate Between Methods

Windows: Alt + Up / Alt + Down Mac: Ctrl + Up / Ctrl + Down

Jumps to the previous or next method in the file. Saves a lot of scrolling in long classes.

11. Toggle Field Watchpoint (hidden gem)

Right-click on a field in the editor, then select Toggle Field Watchpoint.

This one is underused. A watchpoint pauses execution whenever the value of that field changes, showing you exactly where and when it was modified. Invaluable when tracking down unexpected state mutations in a running application. You don’t need to scatter debug print statements everywhere — just set a watchpoint and let the debugger do the work.

12. Evaluate Expression During Debug (hidden gem)

Windows: Alt + F8 Mac: Alt + F8

While paused at a breakpoint, open this and run any expression against the current state of your program. Call methods, inspect objects, test logic — without restarting. One of the most powerful debugger features and one of the least used.

13. Extract Method / Variable

Windows: Ctrl + Alt + M (method) Ctrl + Alt + V (variable)
Mac: Cmd + Alt + M (method) Cmd + Alt + V (variable)

Select any expression and extract it into a named variable or a separate method. IntelliJ handles the refactor cleanly. Use this constantly when cleaning up bloated methods.

14. Inline Variable (hidden gem)

Windows: Ctrl + Alt + N Mac: Cmd + Alt + N

The opposite of Extract Variable. If you have a variable that is only used once and adds no clarity, this replaces it inline. Useful during cleanup when you realize a variable name isn’t earning its keep.

15. Live Templates

Windows / Mac: Ctrl + J

Type a short abbreviation and expand it into a full code block. sout becomes System.out.println(), fori becomes a for loop. You can also create your own. Go to Settings, search “Live Templates”, and build whatever boilerplate you type repeatedly.

16. Structural Search and Replace (hidden gem)

Edit menu, then Find, then Search Structurally.

This is find and replace but it understands code structure, not just text. You can write patterns that match code semantically — for example, find all method calls with a specific signature and replace them. Almost nobody uses this. It is genuinely powerful for large refactors.

17. Increase IntelliJ Memory Allocation

Help menu, then Change Memory Settings.

By default IntelliJ runs with a fairly conservative heap size. On large codebases this shows up as sluggishness, freezes during indexing, or outright out of memory errors. The fix is straightforward — go to Help, Change Memory Settings, and bump the heap size up. 2048 MB is a reasonable starting point. 4096 MB if your machine can spare it and you are working on a large monorepo or multiple projects simultaneously.

After changing it, restart IntelliJ. You will notice the difference during indexing and when running multiple run configurations at the same time. If you are on a machine with 16 GB of RAM or more and you have not done this yet, do it now.

18. HotSwap — Reload Changed Classes Without Restarting (hidden gem)

While attached to the debugger, press Windows: Ctrl + Shift + F9 Mac: Cmd + Shift + F9 to recompile the current file. Then go to Run, then Debugging Actions, then Reload Changed Classes.

This pushes the recompiled class directly into the running JVM without stopping and restarting the application. No full redeploy, no waiting for the server to come back up. You make a change, reload, and keep debugging from where you were.

There are limitations — you cannot hot swap structural changes like adding new methods or changing method signatures. But for logic changes inside existing methods, it works reliably and saves a significant amount of time when you are iterating on a fix. In a large Spring Boot application where a full restart takes two or three minutes, this compounds quickly over a debugging session.

If you want to go further, look into DCEVM or JRebel — both extend HotSwap to support structural changes as well. But the built-in version handles most day-to-day cases just fine.

19. The Problems Tab

View menu, then Tool Windows, then Problems. Or look for the Problems tab at the bottom of the IDE.

The Problems tab gives you a consolidated view of every issue IntelliJ has detected across your entire project — compilation errors, warnings, code quality issues, typos in string literals, missing dependencies. All in one place, grouped by file.

Most developers only find out about problems when the compiler yells at them or when something breaks at runtime. The Problems tab surfaces issues passively in the background as you work. You do not have to go hunting — if something is wrong anywhere in the project, it shows up here.

The more useful habit is to check it before raising a pull request. It will catch things like unused imports, unreachable code, or a null safety warning that your eyes skipped over during review. Takes ten seconds and occasionally saves you a comment from a reviewer pointing out something embarrassing.

That covers most of what I reach for daily. If there are specific workflows you want covered — debugging, Git, Spring-specific tooling — let me know in the comments.

Steve

• 1 Manager

• 4 Team Members (including you)

Day One: Establishing Your Presence

1. Workspace Setup

   • Arrive early to set up your physical workspace

   • Ensure your computer and necessary peripherals are functioning

   • Locate essentials: restrooms, break areas, meeting rooms

2. Team Introduction

   • Meet with your manager for an initial briefing (30-45 minutes)

     • Discuss team structure, your role, and immediate priorities

     • Understand reporting structure and communication preferences

   • Introduction to your three team members (15 minutes each)

     • Learn about their roles and current projects

     • Understand how your work will intersect with theirs

3. Environment Setup

   • Set up your development environment with help from a designated team member

   • Request access to necessary systems and repositories

   • Familiarize yourself with the office network and any VPN requirements

4. First Team Meeting

   • Attend your first team meeting (if scheduled)

   • Introduce yourself briefly to the whole team

   • Observe team dynamics and meeting structure

Week One: Deep Dive and Integration

1. One-on-One Sessions

   • Schedule 45-minute sessions with each team member:

     • Team Member 1 (Day 2): Focus on codebase structure and coding standards

     • Team Member 2 (Day 3): Discuss testing practices and CI/CD pipeline

     • Team Member 3 (Day 4): Explore system architecture and design patterns

     • Manager (Day 5): Review week's progress and set concrete goals

2. Hands-On Tasks

   • Complete a small task assigned by your manager

   • Aim to make your first commit and go through the team's code review process

   • Shadow a team member during a debugging or problem-solving session

3. Team Dynamics

   • Observe how the team collaborates during the day

   • Understand each team member's strengths and specialties

   • Identify the go-to person for different types of questions or issues

4. Local Environment Mastery

   • Ensure your local development environment mirrors production

   • Practice the full development cycle: from local changes to deployment

Week Two and Beyond: Contribution and Growth

1. Increased Responsibility

   • Take on a more substantial task or feature

   • Collaborate directly with one of your team members on a shared task

   • Start participating in code reviews for your peers

2. Regular Check-ins

   • Daily quick sync with your manager (5-10 minutes)

   • Weekly one-on-one with manager (30 minutes)

     • Discuss progress, challenges, and upcoming priorities

     • Seek and provide feedback

3. Team Contribution

   • Volunteer to lead a section of the next team meeting

   • Offer to document a process or update existing documentation

   • Propose an improvement to the team's workflow or tooling

4. Cross-Functional Interaction

   • Attend a meeting with a interfacing team (e.g., product, design, or ops)

   • Understand how your team's work impacts other departments

5. Continuous Learning

   • Set up a weekly knowledge-sharing session with rotating topics

   • Each team member (including you) presents on a relevant technology or concept

Targeted Interaction Plan

1. Manager

   • Daily: Quick morning sync to align on day's priorities

   • Weekly: In-depth one-on-one for progress review and feedback

   • Ad-hoc: Don't hesitate to ask for clarification on expectations or team dynamics

2. Team Member 1 (Codebase Expert)

   • Week 1: Deep dive into codebase structure

   • Week 2: Pair programming session on a complex feature

   • Ongoing: Go-to person for code organization questions

3. Team Member 2 (Testing Guru)

   • Week 1: Overview of testing strategy and tools

   • Week 2: Collaborate on writing tests for your first feature

   • Ongoing: Consult on best practices for test coverage

4. Team Member 3 (Architecture Specialist)

   • Week 1: System architecture walk-through

   • Week 2: Discuss how your current task fits into the larger system

   • Ongoing: Involve in discussions about scalability and system design

5. You

   • Week 1: Focus on absorbing information and establishing relationships

   • Week 2: Start contributing actively in discussions and code reviews

   • Ongoing: Rotate sitting next to different team members to learn from their workflows

Best Practices for Onsite Collaboration

1. Leverage Physical Proximity

   • Use face-to-face interactions for complex discussions

   • Observe and learn from your teammates' problem-solving approaches

2. Respect Shared Spaces

   • Be mindful of noise levels in open office areas

   • Keep shared spaces clean and organized

3. Utilize Whiteboarding Sessions

   • Suggest in-person brainstorming for complex problems

   • Practice explaining your ideas visually

4. Build Rapport

   • Join team members for lunch or coffee breaks

   • Participate in any team-building or after-work activities

5. Balance Digital and In-Person Communication

   • Use chat for quick questions, but don't shy away from walking over for longer discussions

   • Be present and engaged during in-person meetings

Remember, your goal is to become an integral part of this small, onsite team as quickly as possible. Focus on building strong, collaborative relationships with your manager and three teammates while rapidly coming up to speed on the technical aspects of your role.

8:30 AM - 8:45 AM: Arrival and Mindful Start

• Arrive at the office

• Practice a short mindfulness or focus exercise

• Review personal goals for the day

8:45 AM - 9:00 AM: Workspace Setup and Task Prioritization

• Set up workstation for the day

• Review and prioritize tasks using a task management tool

9:00 AM - 9:15 AM: Daily Sync with Manager

• Quick check-in on priorities

• Address any blockers or concerns

• Align on day's objectives

9:15 AM - 9:30 AM: Team Stand-up

• Participate in daily stand-up (if team follows agile practices)

• Share your progress, plans, and any blockers

9:30 AM - 10:45 AM: Deep Work Session I

• Focused coding time on highest priority task

• Use Pomodoro technique (25 min work, 5 min break)

10:45 AM - 11:00 AM: Active Break

• Short break with physical movement (stretch, walk)

• Hydrate and snack if needed

11:00 AM - 12:00 PM: Learning and Exploration

• Study codebase or documentation

• Work through any training materials

• Explore new technologies relevant to your work

• Document learnings in personal knowledge base

Afternoon

12:00 PM - 1:00 PM: Lunch and Networking

• Take a full hour for lunch

• Join different team members each day to build relationships

• Once a week, lunch with a member from another team

1:00 PM - 2:15 PM: Collaborative Work Session

• Pair programming session

• Code review participation

• Collaborative problem-solving

• Rotate pairing partners throughout the week

2:15 PM - 2:30 PM: Quick Break and Reflection

• Short break to refresh

• Reflect on learnings from the collaborative session

2:30 PM - 3:00 PM: Targeted Skill Development

• Work on a specific skill identified in your onboarding plan

• Could be technical (e.g., new language feature) or soft skill (e.g., communication)

3:00 PM - 3:45 PM: Team Member 1:1 or Cross-functional Meeting

• Rotate through team members each day for 1:1s

• On days without 1:1s, attend cross-functional meetings or work on documentation

3:45 PM - 4:00 PM: Active Break

• Short break with physical movement

• Informal chat with a team member if possible

4:00 PM - 5:00 PM: Deep Work Session II

• Focused work on secondary priority tasks

• Implement learnings from earlier sessions

5:00 PM - 5:20 PM: Daily Wrap-up and Documentation

• Document progress and learnings

• Update personal notes or team wikis

• Reflect on the day and plan for tomorrow

• Update task management tool

5:20 PM - 5:30 PM: Manager Check-out and Shutdown

• Brief check-out with manager

• Share any significant learnings or blockers

• Clean up workstation and prepare for next day

Weekly Special Blocks

Monday Morning: Weekly Planning

• Review and set goals for the week

• Align personal objectives with team sprint goals

Friday Afternoon: Weekly Retrospective

• Personal reflection on the week's progress

• Identify areas of improvement for next week

• Share key learnings with the team

Bi-weekly: One-on-One with Manager

• In-depth discussion on progress, challenges, and career development

• Seek and provide feedback

• Adjust onboarding plan as needed

Monthly: Team Building Activity

• Participate in team social events or structured team building exercises

Flexible Blocks (to be scheduled as needed):

• Technical Deep Dives: Schedule 90-minute sessions with different team members for in-depth technical discussions.

• Open Source Contribution Time: Allocate time to contribute to relevant open-source projects (if encouraged by the company).

• Innovation Time: Set aside time for experimenting with new ideas or technologies that could benefit the team.

• Mentoring Sessions: As you progress, start mentoring interns or newer team members.

Customization Notes:

1. Adjust times based on team's working hours and meeting schedules.

2. Be flexible, especially for urgent tasks or spontaneous learning opportunities.

3. Gradually increase deep work sessions and decrease structured learning time as you progress.

4. Use time-tracking tools to understand where your time is spent and optimize accordingly.

5. Regularly review this schedule with your manager, adjusting based on your progress and team needs.

6. Consider using different focus techniques (e.g., Pomodoro, time-blocking) to find what works best for you.

7. As you become more integrated, allocate time for cross-team projects and leadership opportunities.

Remember, while structure is important, the key to successful onboarding is remaining flexible and open to learning opportunities as they arise. Regularly reassess this schedule to ensure it's supporting your growth and contribution to the team.

1. Immediate Action Items

   • Set up your workstation and request any missing accesses

   • Schedule 15-30 minute 1:1s with all team members for the first week

   • Request access to the codebase and start exploring

   • Ask for company and project documentation

   • Set up your IDE and development tools

2. Rapid Integration

   • Introduce yourself concisely to your team, focusing on your skills and experiences

   • Request a product demo from a user's perspective

   • Ask for an architectural overview of the system

   • Learn about the development workflow, including version control, code review, and deployment processes

   • Understand the team's coding standards and best practices

3. Early Contributions

   • Ask for a small, manageable task to work on immediately

   • Begin setting up your development environment

   • Start documenting any unclear processes or setup steps you encounter

   • Review recent pull requests to understand the team's code review process

4. Cross-team Networking

   • Request a list of key team members and stakeholders

   • Understand how your role interacts with other departments

   • Identify the main users or clients of your team's software

5. Goal Setting

   • Draft initial personal 30, 60, and 90-day goals based on your day one learnings

   • Include goals related to technical skills and domain knowledge acquisition

Week One: Accelerate Your Integration

1. Deepen Understanding

   • Complete setting up your development environment

   • Aim to make your first code commit by the end of the week

   • Continue 1:1s with team members and key stakeholders

   • Start mapping out the main components and services of the system

2. Expand Contributions

   • Take on additional small tasks as you complete your initial assignment

   • Actively participate in team meetings and discussions

   • Offer to pair program with a team member to learn the codebase faster

3. Technical Deep Dives

   • Request or organize technical deep dive sessions on critical systems

   • Start learning about the rationale behind key architectural decisions

   • Understand the testing strategy and tools used in the project

4. Process Familiarization

   • Understand and start using the team's task management and communication tools

   • Familiarize yourself with the team's agile processes (if applicable)

   • Learn about the team's approach to technical debt management

5. Knowledge Acquisition

   • Dedicate time each day to explore different parts of the codebase

   • Review any available internal training materials

   • Start building a glossary of domain-specific terms and concepts

Week Two and Beyond: Maximize Your Impact

1. Increase Contributions

   • Take on more complex tasks and projects

   • Actively participate in code reviews and technical discussions

   • Start contributing to architectural discussions

2. Continuous Improvement

   • Propose improvements to processes or documentation based on your fresh perspective

   • Share your onboarding experience and suggest enhancements

   • Look for opportunities to improve code quality or system performance

3. Expand Your Knowledge

   • Continue daily exploration of different parts of the codebase

   • Seek out and complete any available internal training materials

   • Dive deeper into the business domain:

     • Read relevant industry publications or whitepapers

     • Understand the competitive landscape and market trends

     • Learn about the end-users and their needs

4. Proactive Problem Solving

   • Identify challenges within your team or project

   • Develop and propose solutions to your manager

   • Look for ways to automate repetitive tasks or improve development workflows

5. Feedback and Adjustment

   • Schedule a check-in with your manager to review your 30-day goals

   • Seek specific feedback on your contributions and integration

   • Adjust your 60 and 90-day goals based on new insights

Best Practices for Accelerated Onboarding

1. Be Aggressively Proactive

   • Don't wait for information or tasks to come to you

   • If something is unclear, ask immediately

2. Maximize Every Interaction

   • Come prepared to every meeting with questions and ideas

   • Follow up on discussions with actionable items

3. Leverage Documentation Efficiently

   • Use existing documentation to answer questions quickly

   • Contribute improvements to documentation in real-time

4. Balance Learning and Doing

   • Aim for a mix of hands-on tasks and knowledge acquisition each day

   • Apply what you learn immediately to reinforce understanding

5. Communicate Proactively

   • Keep your manager and team updated on your progress

   • Flag potential issues or roadblocks as soon as you identify them

6. Seek and Offer Help

   • Don't hesitate to ask for help when stuck

   • Offer your skills and perspective to assist others

7. Cultivate a Growth Mindset

   • Embrace challenges as learning opportunities

   • Be open to feedback and different perspectives

Additional Tips for Software Engineers

1. Master Your Tools

   • Invest time in learning shortcuts and advanced features of your IDE

   • Familiarize yourself with the team's preferred debugging tools

2. Understand the Full Stack

   • Even if you're specialized, gain a basic understanding of all layers of the application

3. Stay Current with Technology Trends

   • Follow relevant tech blogs, podcasts, or YouTube channels

   • Participate in local tech meetups or online communities

4. Practice Continuous Learning

   • Set aside time for coding challenges or personal projects

   • Explore new languages or frameworks relevant to your work

5. Develop Soft Skills

   • Work on clearly communicating technical concepts

   • Practice active listening in meetings and discussions

Remember, the goal is to become a valuable contributor as quickly as possible while building a solid foundation for long-term success. This accelerated approach demonstrates your initiative and enthusiasm, setting a positive tone for your tenure with the company.