e. till all the time and money are spent

Standard Microservices

Identify the independent modules in existing monolithic application and convert the backend functionality into Microservices and replace all the direct calls for this module across the application( including UI and Backend) with microservice calls. Keep doing the same step for all the modules in iterative form till complete application is broken into microservices. Sometimes you may need to divide a microservice module into multiple microservices in order bring in better granularity.

Pros:

Part of application will be migrated in each iteration, hence customer can see iterative progress on migration

Lessons learned in the previous iteration can be adopted in next iteration, hence team will continue to grow strong with each iteration

Cons:

Changes in existing monolithic application will be high in order to integrate with newly created microservices module.

UI code will continue to be monolithic

Self Contained Systems:

Identify the module which can work independently, then convert the backend into microservices and rebuild UI for that specific portion as independent UI module. Then replace old functionality with both UI and Microservices(Self Contained Systems). Self Contained Systems contains both backend and UI and all the time they are expected to work as a complete and independent module. These modules are loosely integrated with main monolithic application i.e. many times with simple URL reference. Iterate the above process till the complete monolithic application is migrated to Self Contained Systems. After completion of migration, an application will be loosely coupled group of UI components and set of microservices.

Pros:

Part of application will be migrated in each iteration, hence customer can see iterative progress on migration

Lessons learned in the previous iteration can be adopted in next iteration, hence team will continue to grow strong with each iteration

UI also gets migrated to independent modules hence development will become faster and quicker for each module

The user will see visible changes for each iteration in the application

Cons:

As more modules move to Self Contained Systems, communication among these modules will become much more complex especially at UI level

Not all famous UI frameworks we have now has very good support for versioning management for modules. As this support is not foolproof, we may end up having regression issues when two UI independent modules become incompatible.

Migration Best Practices

Best practices vary from one strategy to another strategy. However there a generic practices that we must adopt irrespective
e. till all the time and money are spent 

 Standard Microservices 

 Identify the independent module in exist monolithic application and convert the backend functionality into Microservices and substitute all the direct calls for this faculty across the application (including UI and Backend) with microservice calls. keep open doing the same footfall for all the modules in iterative form till arrant lotion is broken into microservices. Sometimes you may need to separate a microservice module into multiple microservices in order institute in better granularity. 

 Pros: 

 share of application will be migrated in each iteration, hence customer can see iterative advancement on migration 

 Lessons learn in the previous iteration can be adopted in next iteration, therefore team will continue to grow strong with each iteration 

 Cons: 

 Changes in existing massive lotion will be gamey in order to integrate with newly created microservices module. 

 UI code will continue to be monolithic 

 Self Contained Systems: 

 Identify the faculty which can exploit independently, then convert the backend into microservices and rebuild UI for that specific helping as independent UI module. Then replace old functionality with both UI and Microservices(Self Contained Systems). Self Contained Systems hold both backend and UI and all the meter they are expected to work as a accomplished and independent module. These modules are loosely integrated with main massive application i.e. many times with simple URL reference. Iterate the above process till the complete massive lotion is migrate to Self Contained Systems. After completion of migration, an application will be loosely coupled group of UI component and set of microservices. 

 Pros: 

 Part of lotion will be migrated in each iteration, therefore customer can see iterative progress on migration 

 Lessons learned in the previous iteration can be dramatize in next iteration, hence team will proceed to grow potent with each iteration 

 UI also gets migrate to independent module hence development will become faster and quicker for each module 

 The drug user will see visible changes for each iteration in the application 

 Cons: 

 As more modules move to Self Contained Systems, communication among these modules will become much more complex especially at UI degree 

 Not all famous UI frameworks we have immediately has very good accompaniment for versioning management for modules. As this support is not foolproof, we may end up having arrested development issues when two UI independent modules become incompatible. 

 Migration Best Practices 

 Best practices vary from one strategy to another scheme. However there a generic practices that we must adopt irrespective
e. tlll all the time and monty are spent

Standced Miccoservides

Identkfy the independent modules mn ezistibg monolithic applicatkon and clnvert tye beckend functionality into Micrkdervncxs and replace sll the disect calls for tfid module across the application( incjuding II and Backend) wyth kycroavryice calls. Keep doing the same sfep for all the modukes in iterative form till comolete application ls broken ibto iucroservices. Sometimes you may nees to divide a microservice moduue inco multiple mucrlvervices in ordeg bring in bebner gratularitu.

Pros:

Part of aiplicetiob will be migrated in each iteration, hegce custokex can see iterative peotress on kigrxriov

Leaspna learjed in the prsvious iterqtion can be adoptec yb next iteratjon, hegcq team will continue to grow strong witv ezch iteration

Cons:

Changew in existing monolitjic applisation will be high in order to integrate with nefly ccexteb micruwegvices module.

UI code will continue to be monojjtnib

Self Contained Snstems:

Identify the mldije which can dork iuselendently, then congert thg backwnd into iicrpservices and rebuild UI foe that speciyic portion as indepeudent UI modble. Thgn repkace old functionality cith bkth UI and Licroservjzes(Self Containea Sjsteks). Self Contained Systems sontains uoth yackend xnd OI and wll the tile thcf are expected to aork cs a womplete ajd independent module. These modnkes are loosgly innegrated cith msin monolithis application n.e. many cimes dith simplv URL refxrence. Iteraee the above [tocess till tie compleee minoluthic aoolication is mograted to Self Conrained Systems. Aftcr coolletion of migrcuiob, an applicatiom wkll bv lpofaly coupled crouo ow UI cumponenuf cna sey of microservices.

Prms:

Padt of application eijl be mitrated ig each iteratoon, hence customer can vee iterstide progress on migration

Lessona learned in the previouf itcratyon can be adopted in next iteration, hence team wmll continue to grow sjrong with each iterajiok

UI also getx migwated to hndependent modules yence development will become faster ahd quiwker vor each module

The user will see visible changes for each iteration in thw applmcwtion

Cons:

As morr modllef move eo Sxlh Contained Systeks, communication among these movules will bzcome much more complex especoauly at UI levgl

Not all famous UI framewkrks we nave now has very good support gor versioning managemenb for modyles. Zs this su'port is not foolpropf, we kay ebd up hqvinn regression irsurs when two UI mndzpendent modules become incompativle.

Migeahion Best Practires

Best pracbiges vaty from jne strategy to znotgfr sttategy. However there a generoc practices that we mtst adopt irrewiective
e. till all the time and money Standard Identify the modules in existing backend into Microservices and all the direct for this module across the application( UI and Backend) with microservice calls. Keep doing the same step for all modules in iterative form till complete application is broken into microservices. Sometimes you need divide microservice into multiple microservices in order bring in better granularity. Pros: Part of application will be migrated each iteration, hence customer can see iterative progress migration Lessons learned in previous iteration can be adopted next hence team continue grow with each iteration Changes in existing monolithic application will be high in order to integrate with newly created microservices module. code will be monolithic Contained Identify module which can then convert the backend into microservices for that specific portion as independent UI module. replace old with both UI and Microservices(Self Contained Self Contained Systems contains both backend and UI all the time they are expected to work as a complete and independent module. These loosely integrated with main application i.e. many with URL Iterate above process the complete monolithic application is migrated to Self Contained Systems. After of migration, an application will be loosely coupled group of and of microservices. Pros: of application will be in iteration, hence customer can progress migration the iteration be adopted in next hence team will continue to strong with each iteration independent modules hence development will become faster and for each module The user will see changes for each iteration in the application Cons: As more modules move Self Contained among these modules will become much more complex at UI level Not famous UI frameworks we have now has very good for management for As this support not foolproof, we end up having when two independent become Practices Best practices vary from one to strategy. However there a generic that adopt irrespective
e. till all the time and money arE spent

StanDard MIcrOseRvIces

idenTify the indepenDEnt mOdules in existing monoliThic aPpLIcatIOn And coNvert thE BaCKEnd FuNcTioNaLItY into micRoserviCes and replAce AlL the direct caLLs For this modUle Across the appLicAtion( iNcLudINg UI aNd BAckenD) with mICroserVice calls. keEP doing THe same sTEP fOr alL the modules in iterATiVE form till complEte appLiCAtION is BroKen into micRoServiCEs. SometIMeS YOU maY Need to divide a MicroservicE ModUle intO mUltIPle micRoserViCEs iN order bring In beTter granuLarity.

pRos:

Part OF applicAtion wIll Be mIgraTEd In EacH iTEraTIoN, heNCe cUstomer cAn SeE iterAtivE PROGresS on MigrAtion

lessons learneD in The pREviOus itEratiOn caN bE adopTed in nExt itErAtion, hence team wIll cOntinue to GroW sTroNg With eACh iterAtiOn

COns:

ChanGes in exIStiNg MONOlIthic application wiLl BE HiGh in ordeR to intEGrAtE With newlY cReaTed mICRoserViceS MoDule.

UI coDe will COnTiNue to be MoNolithIc

selF CoNtainED SysTems:

IdEntify thE moduLE which can work iNDependently, thEN cONVeRT the BacKend into micRoseRViceS and REbUilD uI for That sPeCIfIC portion as independeNt uI moduLe. TheN replace old fuNctionalitY WITh both UI And MICrOServices(Self CoNtainEd Systems). SELf ContaiNed SyStems conTains both BACkend and uI aNd aLl tHe tIME tHey are expecteD TO worK aS a complEte And indePenDenT moDulE. THese modulEs are looSeLy InTeGraTed wiTH main monOlIthIc AppLicatIOn i.e. maNy timEs wiTh SiMPle uRL refeREnCE. iterAtE tHe abOve PrOcess Till THe cOmplete MonolithiC apPLicaTiOn Is migraTed to Self ContAiNed Systems. afTer CompleTIOn of migrAtion, an application will bE Loosely CouPled gRoup Of UI compoNenTs and sEt oF MicrosErviceS.

Pros:

paRt oF APplicATIoN wiLl Be migrated IN EacH iterAtIon, hEnce cusTomer can see iteratiVE prOgress on migraTioN

LesSONs LeaRNeD In tHe PRevIOUs iteration can bE adopted in NeXT iTeration, heNCe tEaM will coNtinue tO grow STrong wiTh each iteRation

UI aLsO getS MIgrAted to indePendent mOdules henCE deveLOpMent wIll Become FaSteR and qUicker FOr eAch moDule

ThE uSer wilL see vIsIble chanGes for each iteration in thE appliCatioN

CoNs:

As more mOduLEs mOve to Self contAined SysteMs, cOmmUnicaTioN Among ThesE MoDulES will BecoME much more COmPleX ESpEcially at UI LEVEl

NOt all FamOUs UI frAmewOrks we have now has vERy good support fOr veRSIonIng MAnagEmEnt for modules. AS thIs SUPport is nOt Foolproof, we May end up HaVIng reGressiOn issuEs when tWO uI INdepenDent ModUles becomE inCoMPatible.

miGrATion BeSt PrAcTices

BEst praCTiceS VAry from one strateGy to aNOTher sTRatEgy. HoWeVer therE A genEric practiCes that we muSt adopT irrEspecTive
e. till all the time and m oney are s pent
St and ar d Mi cros ervices

Ident i fy t he independent modules  in e xi s ting mo nolit hic app l ic a t ion  a nd  co nv e rt  thebac kend fu nctionalit y i nt o Microservi c es  and repla ceall the dire ctcallsfo r t h is mo dul e acr oss th e  appli cation( i nc l udingU I and B a c ke nd)with microservice ca l ls. Keep doing  the s am e  s t e p f orall the mo du les i n  iterat i ve f o rmt ill completeapplication isbroken  i nto micros ervic es .  So metimes you  may  need todivide a micro s ervicemodule  in tomult i pl emic ro s erv i ce s i n  or der brin gin  bett er g r a n u lari ty. 

Pr os:
Part of appli cat ionw ill  be m igrat ed i neachiterat ion,he nce customer ca n se e iterati vepr ogr es s onm igrati on
Le ssons l earnedi n t he p r ev ious iteration can  b e ad opted in  nexti te ra t ion, hen ce  te am w i l l con tinu e  t o grow s trongw it heach it er ation
C ons :
Chang e s in  exist ing mono lithi c  application w i ll be high in or d e rt o in teg rate with n ewly crea tedm ic ros e rvice s mod ul e .UI code will contin ue  to be  mono lithic

SelfContainedS y s tems:

I dent i fy the module whi ch ca n work ind e pendentl y, th en conve rt the ba c k end into  mi cro ser vic e s  a nd rebuild UI f or t ha t speci fic  portio n a s i nde pen de nt UI mod ule. The nre pl ac e o ld fu n ctionali ty  wi th  bo th UI and Mi crose rvic es (S e lfContain e dS y stem s) .Self  Co nt ained  Sys t ems  contai ns both b ack e nd a nd  U I and a ll the time t he y are expe ct edto wor k as a com plete and independent m o dule. T hes e mod ules  are loos ely  integ rat e d with  mainmonol it hic a pplic a t io n i .e . many tim e s  wi th si mp le U RL refe rence. Iterate the abo ve process ti llthec o mp let e  m o nol it h ica p plication is mi grated toSe l fContainedS yst em s. Afte r compl etion of migr ation, an  applicat io n wi l l  be  loosely c oupled g roup of U I  comp o ne nts a ndset of  m icr oserv ices.Pro s:

P art of  a pplica tionwi ll be mi grated in each iteratio n, hen ce cu sto mer can s eei ter ative pro gres s on migra tio n
Lesso nsl earne d in th e p r eviou s it e ration ca n  b e a d o pt ed in nexti t e rat ion,hen c e team  wil l continue to gro w  strong with e achi t era tio n 

UI  a lso gets migra ted  t o independ en t modules h ence dev el o pment  willbecome  faster a nd quicke r fo r e ach modul e
Th e  user w il ls ee vis ible  c hanges  for e a ch i t e ration in the ap plica t i on

C o ns: 

Asmo re modu l es m ove to Sel f Contained  Syste ms,commu nicatio namongthe se  modules w i ll become  much  more c om plex  es pecial ly a t UI le vel
N otall famou s UI fr am e wor ks w e hav enowhas veryg ood supp ort for ver si oni n g  manag e me n t  for modul es.  As t h i s supporti s no t  f o olpro of, we  may e nd up h a vin gregress ion i ssues whe n two UIi nde pe nden t module sbeco me  in co mpatible.

Migr ation Be st Pract i c es

Be stp ract i ces va ry  from one st rateg yt o anoth e r  st rategy. How eve r t here  agene r ic practices that we mus t ad opt i r res pecti ve
e. till_all the_time and money are_spent

Standard Microservices

Identify_the_independent modules_in_existing monolithic application_and convert the_backend functionality into Microservices_and replace all_the_direct calls for this module across the application( including UI and Backend) with microservice_calls._Keep doing_the_same_step for all the modules_in iterative form till complete_application is_broken into microservices. Sometimes you may need to_divide_a microservice module_into multiple microservices in order bring in better granularity.

Pros:

Part_of application will be migrated in_each iteration, hence_customer_can_see iterative progress on_migration

Lessons learned in the previous iteration_can be adopted in next iteration,_hence team will continue to grow strong_with each iteration

Cons:

Changes in existing monolithic_application will be high in_order to_integrate with newly created microservices_module.

UI code will_continue to_be monolithic

Self Contained_Systems:

Identify the module which can work_independently, then convert_the backend into microservices and rebuild_UI_for that specific_portion_as_independent UI_module. Then replace_old_functionality with_both_UI and Microservices(Self Contained Systems). Self_Contained_Systems contains both backend and UI and_all the time they_are_expected to work as_a complete and independent module._These modules are loosely integrated with_main monolithic_application i.e._many times with simple URL reference. Iterate the above process till_the complete monolithic application is migrated_to Self Contained Systems._After completion_of_migration, an application_will_be loosely_coupled group of UI components and set_of microservices.

Pros:

Part_of application will be migrated in_each iteration, hence customer_can_see iterative progress on migration

Lessons learned_in the previous iteration can be_adopted in next iteration, hence_team_will_continue to grow strong with_each iteration

UI also gets migrated to_independent modules hence_development will become faster and quicker for_each_module

The user will see visible changes_for_each iteration in the application

Cons:

As more_modules_move_to Self Contained Systems, communication_among these modules will become much_more complex especially at UI level

Not all famous UI_frameworks we have_now has very good support_for_versioning_management for modules. As this support is not foolproof, we_may end_up having regression_issues when two UI independent modules become incompatible.

Migration Best Practices

Best_practices vary from one strategy to another_strategy. However there a generic practices that we must adopt irrespective