In this lesson, I'll describe the most problematic migration parts for a few popular application types.
As we said in the previous lesson, every application is unique,
and has problems that may not happen during other migrations.

Happily, we can predict some common problems if we categorize applications well.
I'm going to split applications by size and organization structure.

It's very important that some problems you may need to address will not be strictly connected to the code.


Organizational structure,
number and size of teams, or even how application parts are assigned to teams all these factors may be important.
Some of your decisions may be based on it and equally on the code.

This lesson is focusing on the following cases:

You may remember similar cases from the lesson about the importance of keeping dependencies in order from the previous module.
Keep in mind
that some problems may be avoided, and the migration process may be easier
if your application does not contain problematic dependencies.

The biggest problem during the migration of huge applications is, of course, the code.


The worst part of this case is that all your coworkers work on the same code.
So the whole company will face the same issues if something goes wrong.

It may sound silly, but it's easier when big applications are maintained by a small team it's easier to do the migration.
As a team, you work with each other every day.
This fact helps to solve issues that may happen during migration.
Work and tasks can be easily distributed.

It's very unlikely that all teams will take part during migration.
This means that one team has to block development for some time, and other teams will be forced to wait.
This also means that only one team will have a very deep understanding of the process.
To sum up, when you have a huge application with a few hundred thousand LOC,
and multiple fronted teams maintain it
(let's face it: you need a bigger team or multiple teams to maintain an application of that size efficiently)

the main problem may be the coordination and communication between the teams.

---
title: Analysis of potential problems in migration of big existing codebases
description: What may be the problem during migration of big, stale existing codebases
privateVideoUrl: https://stream.mux.com/HGywcY2nm1TEHev2ozx5zuY9uKvpl01VkVp0065r5mah8.m3u8
---

In this lesson, I'll describe the most problematic migration parts for a few popular application types.
As we said in the previous lesson, every application is unique,
and has problems that may not happen during other migrations.

Happily, we can predict some common problems if we categorize applications well.
I'm going to split applications by size and organization structure.
**It's very important that some problems you may need to address will not be strictly connected to the code.**
Organizational structure,
number and size of teams, or even how application parts are assigned to teams all these factors may be important.
Some of your decisions may be based on it and equally on the code.

This lesson is focusing on the following cases:

-   One huge application

    -   One small team
    -   Multiple teams
-   Multiple small applications

    -   One small team
    -   Multiple teams
-   Multiple big applications

    -   One small team
    -   Multiple teams
-   One small application

    -   One small team

You may remember similar cases from the lesson about the importance of keeping dependencies in order from the previous module.
Keep in mind
that some problems may be avoided, and the migration process may be easier
if your application does not contain problematic dependencies.

## One huge application

**The biggest problem during the migration of huge applications is, of course, the code.**
The worst part of this case is that all your coworkers work on the same code.
So the whole company will face the same issues if something goes wrong.

### One small team

It may sound silly, but it's easier when big applications are maintained by a small team it's easier to do the migration.
As a team, you work with each other every day.
This fact helps to solve issues that may happen during migration.
Work and tasks can be easily distributed.

galczo5

What may be the problem during migration of big, stale existing codebases

Analysis of potential problems in migration of big existing codebases

In this lesson, I'll describe the most problematic migration parts for a few

As we said in previous lesson, every application is unique and has problems

that might not happen during other migrations.

We can predict some common problems if we categorize applications well.

I'm going to split applications by size and organization structure, so number

and size of teams that work on that application.

You may remember similar lesson from previous module.

I want to remind you some problems that you may have during migration.

Then we will focus how to prepare a migration plan for each of these problems.

So first case when you have one huge application.

And of course the biggest problem during the migration is the size of

It's just huge, there's a lot of code and you have to migrate it.

The worst part of this case is that all your co-workers work on the same code.

So the whole company will face the same issues if something goes wrong.

What's more, migration process will be blocking for the whole company.

So when that huge app is maintained by one small team, it's easier to migrate

As a team you work with each other every day.

And this fact helps to solve issues that may happen during migration.

And when you have one small team work and tasks can be easily distributed.

It's a bit more complicated when you have multiple teams that maintain that

So it's very unlikely that all teams will take part during migration.

This means that one team has to block development for some time and other teams

And it means that only small part of organization will have a very deep

understanding of the immigration process.

To sum up, when you have a huge application, the main problem you may have is

coordination and communication between teams.

And my advice here is to focus on that coordination and communication between

The second case, when you have multiple small applications, the biggest problem

Because applications are not too big, it should be quite easy to migrate them.

But the problem may happen when you start extracting libraries.

So if you extract one library and then you want to reuse in other applications,

And you have to introduce change in all of them.

When that multiple small applications are maintained by one small team, the

And during the migration, they cannot do anything else.

So it's a problem for the whole organization that your team, the only one team,

spends time migrating existing applications

instead of coding features and fixing bugs.

This time, of course, should be considered as maintenance and it will boost the

When you have multiple teams and multiple small applications, it's a bit easier

The only problem is to start the migration to migrate the first application.

Then you can distribute work between teams.

And again, the biggest problem will be communication and coordination between

So you probably noticed, come on part, when you have one huge application or

when you have multiple teams, you always have to deal with communication and

And it's very, very important because if you don't know how to coordinate teams

some teams will be blocked during migration.

When you have multiple big applications, as you may expect, this case is

similar to the case of multiple small applications.

The difference between multiple big applications and multiple small

applications is that every action will take more time to execute.

Every issue, every back, everything will take more time to resolve.

And I believe that everyone knows that this kind of migration is not a piece of

It's pretty complex operation to do and it's way better to be well prepared.

No matter if your organization is built by one or multiple teams, you will have

Sometimes you cannot solve complex problems with simple solutions.

So my advice here is to focus on preparation.

So when you have one small application, I don't see any problem.

So no matter if you have one small team or multiple teams, small applications

You can even use that automatic migration from previous lesson and it's done.

And you don't need to spend time on migrating it.

The main goal of this lesson was to inform you to remind you about the problems

It's important to know what may happen because it lets you prepare for the

And no matter if you have one huge application or multiple small applications,

you will have some problems and it's easier to deal with them if you have some

ideas what may be wrong with migration process.

In the next lesson, we will focus on preparing the migration plan.

It's often skipped stage, but if you go with it, it will help you in long and

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Masterclasses

Tutorials

Fullstack React with TypeScript