Modernize your legacy application to get the scalability of microservices while staying in compliance.

Modernizing your legacy applications to take advantage of modern technologies doesn’t require a rewrite.  Learn how to update the architecture of your existing applications while keeping all business rules intact.  Our custom designed process injects modern architecture into existing applications so all your compliance rules are kept in place, from start to finish.

Dependency Injection.

We’ve all heard about it, but what is it and why is it important?

The Dependency Inversion Principle, and Dependency Injection, is the key to any modern architecture, and the first thing we must get in place for a legacy system.  In this module we review the theory of what the Dependency Inversion Principle is and what the advantages are in having it.  We also cover how to implement this principle to break the tight coupling that cripples most legacy applications.

Internal Services.

Now that we have Dependency Injection, how do we take advantage of it?

Dependency Injection allows us to inject code anywhere we need it, but that code must have a certain structure to be useful.  In this chapter of the class we examine how internal services are used and what their advantages are.  We discuss Interfaces and how they make our code loosely coupled, then we review some techniques on how to rafactor existing code into services.   

Unit Tests

Automating tests to ensure quality and dependability

Once we understand how to untangle the tightly coupled code into injected services, we can start creating unit tests to ensure these services perform their duties as expected.  This module explores how unit tests are used, and how to integrate them into an existing system.


Enhancing data access for application stability

Data access is one of the most fragile pieces of an application since it must adapt to changes in surrounding systems.  A special kind of service called a repository can be used to insulate the system from changes to database structures.  This module examines how repositories are created, what their responsibilities are, and how the complicated process of refactoring an existing system to use repositories can be pursued.  

Mocking for Stability

Mocking services to test failure conditions and further separate the concerns

Extending the module on Unit tests, we show how we can test internal services that interact with external services, such as repositories.  Mocking external services is a critical piece of our unit testing strategy, and the details of how to do this will be explained.

Updating the UI

Bringing it all together to update the UI and release our new architecture

All the work we have done so far has been in the back ground.  The UI cannot be ignored, though, and in this unit we discuss how to refactor the data entry forms so they can be testable just like the rest of the application. We discuss how to refactor to Controllers whether the current architecture supports them natively or not.  Once our interactions are in controllers they are also testable, thus completing our journey to make our application fully testable end to end.

Modernize Your App Today!

Make your team more productive by scheduling a class today. They will be releasing features faster than you ever thought possible, while still observing all compliance rules.