Brittbot

Upgrading from Data Center Tech to Software Engineer

A black woman with natural hair studying software engineering topics on her desktop computer at her desk inside her home. In the top right corner create a progress bar labeled "XP" that's half-way full.

Google Fullstack Software Engineer Roadmap Created By Gemini

—

by

Brittany Gates
in

I am in the part of my journey to upgrade from a Data Center Technician at Google to a Software Engineer in the company where I need a detailed roadmap. I used the website Developer Roadmaps and found it lacking. However, that’s a free source so I won’t complain too much. Since I use Gemini for many other tasks, I decided to ask for it to give me a Google Fullstack Software Engineer Roadmap. And it did! In today’s post I’ll review what the LLM created and my study plan.

Gemini’s Google Fullstack Software Engineer Roadmap

First, I like Gemini’s introduction to its roadmap for me:

Here is a comprehensive roadmap designed to help you transition from your current tech stack and personal project experience to an L3 Fullstack Software Engineer role at Google, with a strong focus on areas critical for success in their interview process.

This plan emphasizes not just learning new technologies, but also solidifying core computer science principles and adopting best practices in software development.

I need to explain what the “L3” means. It’s the entry-level role for a Software Engineer (SWE) at Google. This role requires usually 0 to 1 years of professional experience.

Gemini’s approach to creating a roadmap for me is in three phases spanning a matter of months:

  • Phase 1: Foundational Strengthening (Estimated: 2-4 Months)
  • Phase 2: Fullstack & System Design Enhancement (Estimated: 3-5 Months)
  • Phase 3: Software Engineering Best Practices & Interview Prep (Estimated: 2-3 Months, Ongoing)

Let’s review each phase in more detail.

Phase 1: Foundational Strengthening (Estimated: 2-4 Months)

The first phase in the Google Fullstack Software Engineer Roadmap is “about building a rock-solid foundation, especially in areas Google heavily emphasizes” according to Gemini.

In this phase are three topics I’ll cover:

  1. Algorithms & Data Structures (The Most Critical Area)
  2. Unit Testing & Test-Driven Development (TDD)
  3. Deep Dive into Python

I’m glad learning about algorithms and data structures is the first topic because I feel it’s the right time in my studies to do so. Although Gemini suggested I use some Coursera courses to learn this (such as “Algorithms, Part I & II” by Princeton University) I’m going to use the second edition of “Grokking Algorithms” by Aditya Bhargava. I learn better through reading (which I wrote about previously on my blog). However, I will follow the LLM’s plan to practice on LeetCode and HackerRank.

As for Unit Testing I’ll spend time reading the official documentation that Gemini told me to read. I’m not sure if I want to buy a book about that. I may watch a few videos and see how I get along. Basically I need to learn the following:

  • Testing Frameworks: unittest and pytest for Python.
  • Assertions: Understanding common assertion methods.
  • Test Fixtures: Setting up and tearing down test environments.
  • Mocks & Stubs: Isolating components for testing.
  • Code Coverage: Tools and importance.
  • TDD Principles: Write tests before code.

Finally, to get better at Python I will purchase the “Fluent Python” book by Luciano Ramalho. Gemini suggests I dive deeper into the language by learning all of this:

  • Advanced Data Structures: collections module (e.g., deque, Counter, defaultdict), heapq.
  • Generators & Iterators: Understanding lazy evaluation.
  • Decorators & Context Managers: How to create and use them.
  • Metaclasses (Basic Understanding): How they work at a high level.
  • Concurrency & Parallelism: threading, multiprocessing, asyncio.
  • Object-Oriented Programming (OOP): Deeper understanding of classes, inheritance, polymorphism, design patterns.
  • Performance Optimization: Profiling code, using cProfile, understanding GIL.

Is the estimated duration of two to four months doable for me? Yes, if I dedicate myself everyday with at least two hours a study time.

Phase 2: Fullstack & System Design Enhancement (Estimated: 3-5 Months)

The second phase in the Google Fullstack Software Engineer Roadmap “focuses on broadening your fullstack capabilities and introducing system design concepts” according to Gemini.

In this phase are two topics I’ll cover:

  1. Modern Frontend Development
  2. Advanced Backend Concepts & System Design

Frankly, this going to be a new change for me because I’m so used to using Bootstrap. I told Gemini of my current tech stack, and it told me it’s time for an upgrade:

  • JavaScript (ES6+): async/await, Promises, Modules, Destructuring, Spread/Rest operators, this keyword, closures.
  • Framework: React.js (Highly Recommended for Google), Angular, or Vue.js. Focus on one and master it.
  • Component lifecycle, Hooks (for React), State Management (Context API, Redux/Zustand for React).
  • Routing (React Router).
  • Component libraries (e.g., Material-UI, Ant Design, or Shadcn UI if using React with Next.js concepts).
  • Build Tools: Webpack/Vite (basic understanding).
  • CSS-in-JS/Tailwind CSS: Modern styling approaches.
  • Responsive Design: Beyond Bootstrap, understanding Flexbox and Grid.
  • Accessibility (A11y) & Performance: Best practices.

Instead of learning React.js, I’m going to learn Angular since Google created that framework and uses it on internal (and some external) applications. Everything else I’m fine with learning.

As for the backend Gemini gave me this:

  • Flask Mastery: Dive deeper into Flask extensions, blueprints, context, custom decorators, error handling.
  • Relational Databases (PostgreSQL):
  • Advanced SQL: Joins, subqueries, window functions, indexing, optimization.
  • Database Design: Normalization, denormalization, schema evolution.
  • ORM: Deeper dive into SQLAlchemy.
  • NoSQL Databases (Basic Understanding): When to use them (e.g., Redis for caching, MongoDB for flexible schemas).
  • RESTful API Design: Best practices, idempotency, versioning, authentication/authorization (OAuth2, JWT).
  • Microservices vs. Monoliths: Understanding trade-offs.
  • Caching: Strategies (client-side, server-side, CDN).
  • Message Queues: Basic understanding (e.g., Celery with RabbitMQ/Redis for background tasks).
  • Load Balancing & Horizontal Scaling: Basic concepts.
  • Monitoring & Logging: Tools and principles.

Again, this is so much to learn. Which is why I think it’ll probably take me closer to five months to learn instead of three months.

Phase 3: Software Engineering Best Practices & Interview Prep (Estimated: 2-3 Months, Ongoing)

The third phase in the Google Fullstack Software Engineer Roadmap “focuses on polishing your engineering skills and specifically preparing for Google’s interview loop” according to Gemini.

In this phase are two topics I’ll cover:

  • Software Engineering Best Practices
  • Google-Specific Interview Preparation

This phase is heavy on developing the normal workflows for SWEs (such as using Git and going through Code Reviews), along with interview preparation. This phase is last, and I think it should be in my study plan because this is good to learn a month or two before starting interviewing. Thus, I’m not going to start on Phase 3 until probably Q2 of 2026.

My Final Verdict On Gemini’s Google Fullstack Software Engineer Roadmap

Overall, I’m happy with the road the LLM provided. I exported the plan into a Google Doc which resides in my Google Drive. Thus, I have access to it where I go. I also had the LLM add check-boxes to each action item in each topic so I can mark them off as I learn them.

My start date will be the middle of this month (July). I’ll post updates on my blog.