Welcome To The Most Valuable Software Architect Course & Community Ever ...

Designed to Empower You With The Secret to Architect & Test Complex UI Applications at Scale in any UI Framework (React, Angular & Vue) And Level Up Your Career 🚀

✅ Over 70% of students of the UI Architecture Academy (UIAA) have gone on to use the exact techniques and conventions taught in UIAA in their production apps.


Our students include software engineers from Microsoft, Google, Apple and other tech giants.


Many of our students have applied their knowledge gained to increase their seniority and associated compensation (by up to 35%).


It's also framework agnostic, so you can use it on React, Vue, Angular or any frameworks that become popular in the future.

Achieve faster promotions and career advancements by mastering advanced UI architecture techniques. Stand out in your organization as a high-value contributor.


You will gain the technical ability and confidence to lead a team (the right way, without conflict).


Our approach isn’t just about theory; it’s about equipping you with real-world skills that you can immediately apply to your projects.


Our techniques help you manage complexity and keep stress levels low as your projects scale.



Master the Skills to Transform Your Career

You'll learn skills in several key areas that will make you a well-rounded and valuable member of your organization.


You will gain technical excellence, career growth, financial gains and personal and professional improvements:


Technical Excellence

Enterprise Scale Capability 📈

Learn a proven approach to scale your applications to 1 million lines of code, with 5,000+ spec tests or more, ensuring robust and maintainable software.


Predictable Approach 🔍

Develop an easy set of mental models and thinking patterns to guide your coding decisions predictably and reliably, almost on autopilot, allowing you to focus on high-level architecture.

Lifetime Value 🛠️

Learn techniques that are not tied to any single framework.


Whether you use React, Vue, Angular, or any future frameworks, your skills will remain applicable and valuable.

Efficient Testing ⚙️

Apply the Pareto principle of testing – one simple type of test to cover 90% of your use cases, making your testing process efficient and effective.


Low Coupling 🔗

Keep your markup and framework free of business logic. This approach ensures cleaner, more maintainable code that is easier to test and extend.


Simple State Management 🧠

Ensure your state is always predictable and understandable. Our methods simplify state management, making your applications more reliable and easier to maintain.

Career & Financial Growth

Salary Increase💰

Command a higher salary (up to 35%) by utilizing the proven methodology we teach.


Elevate your career and earn what you're worth.

Accelerated Promotions 🚀

Start adding real productive results to your team and projects, increasing your seniority and opening doors to roles like Tech Lead, Principal Engineer, UI Architect, or even CTO.


Become a Respected Team Lead🤝

Learn how to lead a team effectively and collaboratively, gaining respect and buy-in without being seen as a dictator. Foster a positive team environment and drive successful projects.

Personal & Professional Empowerment

Confidence in Leadership 🙂

Gain the confidence to lead development teams without getting into implementation conflicts.


Understand the "why" behind architectural decisions to get team buy-in.

Low Stress & Less Chaos 🧘‍♂️

As your codebase grows, it becomes more stable.


Our techniques help you manage complexity and keep stress levels low as your projects scale.


Think Like An Architect 🤔

Understand the complete picture of UI architecture.


Our program teaches you how to think like a true UI Architect, ready to tackle any challenge.




What's Inside The UI Architecture Academy?

The UI Architecture Academy is a one-stop shop that contains all the core curriculum, coaching calendar, group call recordings and community all in one place! No more lost logins for multiple disparate platforms, we've made everyone's lives way easier!

Core Curriculum

Get access to Logic Room's entire suite of courses through our super low cost accessible to all monthly membership fee 🙌


You will receive access to all our current courses and future courses as we release them, for as long as you're an active member of the community.


When you enrol today, you will have access to:


Scalable Test Driven Development - learn the right way to apply unit testing within your UI apps - (Full Access On Enrolling)


Decision Making & Key Principle For Software Engineers - a complete process and blueprint designed to elevate your skills in the workspace -(Full Access On Enrolling)


React Quickstart - our highly regarded quickstart guide to React just showing you the key things you need to know to get started super quickly - (Full Access On Enrolling)


The UI Architecture Academy - our flagship course which past students have paid over $4,000 for and loved it! 🤫 (Drip fed 1 module a week to avoid overwhelm)


Group Coaching Q&A Calls

Join our expert coaches every week to discuss:


✅ Complex UI architecture problems


✅ Advanced testing strategies


✅ Decision-making processes in development


✅ Any other challenges you’re facing



Our coaches are here to provide personalized advice tailored to your needs. Whether it’s a specific technical issue or advice on another topic covered in the course, you’ll get the support you need.


Flexible Learning on Your Schedule


Life gets busy, and we understand that you may not always be able to join our live sessions.


You may also have timezone concerns but fear not our library of past recordings allows you to learn at your own pace, on your own schedule.


Whether you want to catch up on a missed session or revisit a particularly insightful discussion, you have the flexibility to do so.


We also have the transcripts for each call (warts and all!) so you can search for particular topics within the call recordings.


Community

You're not just signing up for a course where you'll be left on your own without support.


You're joining a supportive community of over 200 happy students. Our community is designed to foster collaboration, knowledge sharing, and professional growth.


Imagine having a network of like-minded professionals at your fingertips, ready to support you, answer your questions, and share their experiences.


Whether you're facing a challenging bug, looking for the best practices in software development, or just need some career advice, our community is here to help.


The sense of camaraderie and collective wisdom makes our community a unique resource that you won't find in a traditional course.


We Transform Software Engineers Into Elite Engineers

Students who train with us don't just learn 'facts'. They get real insight into the hardest part of scaling UI

Architecture and Tests. Hear what our students have to say about our training!


Until Now Students Have Paid Over $3,500+ For This ....

(and all their reviews say they loved it and got great value!)

Many of them have applied these techniques and concepts to get promoted at work and increase their salaries

by anywhere from 15%-35% ... far outweighing the investment in the course!

Costas Ioannou

React Native developer, 5 years
JavaScript/ReactJS

"I don’t think I will be able to write apps without this clean architectural structure. It’s the natural way to do it.”

Razvan Anastasescu

Full-stack developer, 20 years
JavaScript/Vue

“The last part of the program, about abstraction, is where most of the magic happened ... You learn how to decouple the business logic of the app from the framework.”

Mohamed Sallam

Ex-Microsoft Software Engineer/Architect

8 years

"The course takes a very practical approach ... The value you take out of it is comparable to having your own mentor … I highly recommend it!”


Exclusive Offer Available Until The Cart Closes

Now, you can get access to the entire suite of Logic Room courses for a super low monthly fee 😲

And this isn't a payment plan that'll keep you locked in for 12 months 🔓

You can cancel any time should you wish to do so, no hard feelings.

WHAT YOU'RE GETTING INSIDE ...

  • The UI Architecture Academy - our flagship course which transforms software engineers into UI Architects.


  • Scalable Test-Driven Development - learn the right way to apply unit testing within your UI apps.


  • Decision Making & Key Principle For Software Engineers - a complete process and blueprint designed to elevate your skills in the workspace.


  • React Quickstart - our highly regarded quickstart guide to React just showing you the key things you need to know to get started super quickly.


  • Weekly Group Coaching Calls with the Logic Room Team.


  • 24/7 Community Access for those questions where you want multiple perspectives on it.
  • Monthly Challenges & Exercises to keep on honing your skills.


  • Asynchronous support in the DMs.
  • Accelerate your seniority and salary.
  • 14 Day No Risk Money Back Guarantee.


LIFETIME ACCESS

Pay Once To Get Lifetime Access To The Course, Community and Coaching Calls

$3,500

Lifetime Access To The Courses & Calls


OR

MONTHLY ACCESS

Spread the cost with monthly payments, investing a fraction of your monthly income into your future success.

$147 / month

Month To Month. Cancel any time. No Risk.


* this will be increasing to $300/month soon but you can lock in this launch price for as long as you want to stay.


Andrei Fidelman 🔗

Ex-Microsoft Software Engineer/Architect, 8 years

“Anyone thinking in enrolling in the Academy should know the academy can save you a lot of time in understanding the entire picture of Architecture and Testing in UI apps”

Fredrik Lindqvist🔗

Front-end developer, 5 years
JavaScript/C#/.NET

“It’s been a game-changer now when I’ve done this course … I have a new perspective on things ... It’s what I’ve been looking for almost 5 years.”

Javier Valderrama 🔗

Senior Consultant, 10 years
JavaScript, front-end & back-end

“It’s like a recipe … you can have all these ingredients ... but the right master is the one who knows exactly how to combine them."


Our Team

Ilia Tolliu

Technical

Ilia is a member of the founding coaching team. He works with our students pushing them towards career mastery as architects!

Pete Heard

Strategy

Pete founded the company and is responsible for designing our core methodology for UI Architecture.

Rick Blyth

Operations

Rick works on the operational side of Logic Room. He focuses on customer success, marketing and everything in between to ensure Logic Room runs smoothly.

From Frustrated JavaScript Engineer to Empowered UI Architect!

The UIAA Mentoring Programme Shows you the Secret to Architect & Test Complex UI Applications at Scale in any UI Framework (React, Angular & Vue), And Then Up-Level Your Career

Here's what you'll learn inside the UI Architecture Academy ....

Part (1 of 2) - Ultra Fast Testing

In the first 1-6 modules we learn to make testing a UI app so fast, you will never want to ship another SPA without doing it!

Module 1: The Fast-test Architecture

In this first week we explore what you ‘think’ software architecture is about and what it is ‘really’ about…


We learn why testing is so slow because you do not have a go-to ruleset to help you lay out your files and data structures in a way that is consistent and repeatable, no matter how large your components become.


You can stop relying on complicated frameworks like Redux and instead learn the rules that stop your code and tests getting TANGLED.


Then we learn how to map UI architecture to your BRAIN and not React/Angular or Vue meaning you can process it faster.

  • Get more control of your app and feel empowered
  • Reduce your dependency on frameworks meaning you are in charge not the UI Framework
  • Be able to communicate your intent much more easily in your code and with your team
  • Your brain will be happy because the rules make decisions EASY

Module 2: Execution Patterns for Testing Asynchronous Apps

We know the grisly mess that asynchronous programming causes!

If we aren’t deep in spaghetti call-backs then we are trying to swat a promise!

We learn why JavaScript forces unstable and tightly coupled testing architectures when using only callbacks, promises or async and await.

Instead, we learn to manually create and then leverage the observer pattern to gain fine grain control of our app state and therefore get TOTAL control over the Single Page App, and that means your TESTS become easy to READ and WRITE.

  • Learn to make state in your tests predictable meaning you save time
  • Know how to load data properly during your test so you have certainty on your test framework expectations

In training slide...

Module 3: The Anatomy of a Simple Test

Now you have the requisite architecture knowledge, it’s time to write your first simple test.


But unless you have a repeatable pattern for making your test call your production code in EXACTLY the same way as the PRODUCTION code does, your tests are WORTHLESS.


Luckily in this module we learn the control patterns to fully control our app that so that it will load data and track state. Then we leverage the power of ‘black box’ design and test doubles to setup a clean, and clear System Under Test (SUT).

  • Make your tests look like business specs and get the confidence of REAL tests not FAUX tests
  • Step through your production scenario ‘in the test’ meaning you know if the test is accurate
  • Get consistency in all your tests meaning you won’t be confused next time you look at it

Module 4: The Anatomy of a Complex Test

How DO we test COMPLEX app events such as user actions, API responses and application transitions in a single test?


We take principles from the last module and learn how to create consistent test code. This can then layer all of our app events in successive steps which we control without our tests becoming fragmented.


In this lesson we will learn how to build our complex tests meaning no matter the requirement that the suits from the business hand you, you can test it like a BOSS!

  • Learn to avoid ‘false positives’ using 3 architectural principles. This will mean you can test no matter how complex the use case
  • Get consistency amongst your tests and avoid fragmentation, meaning your code stays valuable

Module 5: Vertically Scaling your Test-Suite

Testing at scale becomes slow when you cannot easily VISUALISE multiple paths through your features.


In this module we will learn how you can leverage patterns to build re-usable blocks of setup code in your test suite. It will give you confidence that your production apps are being tested like a real production app, WITHOUT coupling to the framework.


Wave bye-bye to duplicate code and lost ideas, and say hello to tests getting FASTER to write the more you have NOT SLOWER.

  • Learn how to cover any and all use cases which helps you mitigate against unexpected user behaviour
  • See how to build faster tests over time meaning you improve your ability within the tests

Module 6: Horizontally Scaling your Test-Suite

Ever wondered how you can do end-to-end testing in completely different parts of your UI without using end-2-end frameworks like Cypress, Selenium or Protractor?


Probably not, because you didn’t even think it was possible…right?


In this final module you will learn how to test ACROSS your UI that has multiple components, states and views.


Then you will find out how to make your tests work without using end-2-end tests, horrible snapshots OR confusing UI mocks – in fact to do this testing you won’t even need to use React or Angular – how cool is that?


This final module is the mastery to the first part of the training and you WILL walk away with your mind BLOWN.


The final technique you learn here will transform you from an engineer that says you DO TESTING to a UI Architect that says you LOVE TESTING!

  • Get the final rules for you to be able to test ANY UI pattern
  • Find out how to use less tests not more, meaning you spend more time architecting instead of fixing bugs
  • Avoid the complexities of END to END HTML manipulation and view coupled testing
  • Learn to get the ULTRA decoupled UI test architecture!

In training slide...

Before we get into part 2 ... check out these reviews

Andrei Fidelman

EX-Microsoft Software Engineer, 8 years

“Anyone thinking in enrolling in the Academy should know it can save you a lot of time in understanding the entire picture of Architecture and Testing in UI apps.”

Fred Linqvist

Technical Lead @ Hailli HR, 8 years

“It’s been a game-changer now I’ve done this course … I have even sent my engineers back to Logic Room for the same programme!”

Nóra Hajdú

Frontend Engineer @ HTEC, 5 years

“Great course! you should attend this training if you would like to know more about clean frontend architecture and testing.”

Part (2 of 2) - Infinite UI Architecture

In modules 7-12 of the training we further advance your knowledge and show you the architectural rules and software design theory that will let you scale up your UI app to any size.

Module 7: Flat UI Presentation

Do you find yourself spending too much time wrestling with React props? Got way too many complex objects in Redux? or perhaps you end up always fighting with Angular directives?


You could have... a presentation problem!


Left unchecked a UI app subtly buries too much information in the markup of your chosen UI framework. This week is going to blow-the-lid off this simple rule; good architecture starts with good presentation.


In this module we learn the fundamental difference between hierarchical data models and flat models, and how we can detect and fix bad views through the power of better presentation architecture.


In this module we will;

  • Understand why information should only ever flow 'down' through a view
  • Learn the patterns of bad markup and what we should do about them
  • Identify when to use hierarchical and when to use flat models in your architecture
  • Watch a 3-part refactoring demo which shows how to start cleaning up your views and making them use flat presentation
  • Solve a real world complex business problem by cleaning up bad markup and implementing flat presentation concepts

Module 8: The Programmer's Model

Let's face it, with all the hot air about software architecture why does nobody ever give us the ONE rule which makes all the difference?


In this module you will learn what that ONE most important rule in a UI app is! By discovering how an engineer cannot ‘see’ architecture unless they can 'control' it!


We do this by taking what we learned in the last module and creating 'breathing space' in our architecture. Then we can centralise a conceptual model which is designed to let us ‘think’. Trust me, if there is one thing you want to get better at when you are building architecture it's THINK, so...


In this module we will;

  • Learn to visualise and iterate the design of the Programmer’s model using a simple output visualisation technique
  • Iterate on older Programmer's models and pull their design into shape using a 'refinement' process
  • Explore the relationship between the Programmer's Model and the Presentation ViewModel
  • See how the most common types of architectural principles such as Domain Driven Design, The Clean Architecture and MV* patterns can be used with the Programmer's model and integrated into Single Page Applications in general!

In training slide...

Module 9: Reactive Architecture

Whats your biggest fear in a JavaScript UI app? Let me guess. Is it being FORCED to use ES5? Perhaps you need to support IE10 still? {Giggle}, no, no, NO, the true ENEMY at the gates in a JavaScript UI app is... UNWANTED side-effects!


We do NOT want our UI apps to behave unpredictably and start throwing out data in odd situations or at the wrong time. Because apart from being stressful it also makes testing near on... __impossible__!


We are going to shine a SPOTLIGHT right on this issue. Side-effects in a JavaScript UI app are caused by two categories of problem; timing and encapsulation. It's these two things which give rise to BRITTLE behaviour, odd side effects and unhappy engineers who can't keep control!


We will learn to leverage the paradigm of functional reactive architecture to cleanly solve both timing AND encapsulation issues properly. We are going to show you how to force a 'one-way' data flow on your app but without using a sea of complex tools. We will demonstrate to you the simplest way using the lightweight MOBX framework (but you can use any other FRP framework once you learn the rules).


So, in this module we go deep on the following;

  • The observer pattern and what it is. We practice writing one to make sure you can spot it in other places
  • We learn what functional reactive programming ‘actually’ is and how we can leverage it to guard against unwanted side effects
  • What the Reactive core is and how we can use it in our UI architecture to get a stable ‘middle’ to our app
  • What the Reactive view is and how we bind it to our Reactive core using markup
  • How we enable state to flow in our app in a predictable manner without relying upon the constraint of a state container like Redux (although you can still use one once you learn the rules)

Module 10: Dependencies

If you have been shipping UI apps for more than a few years you will have seen the dizzying array of ways that module dependency loading works. Dependency loading is critical to a UI app, but the normal module loading tools do not give us the flexibility we need to SCALE because we are not in 'control' of the lifecycle.


We need control because often our dependencies are hard to test and hard to extend. For this reason we must have a way to centralise and dynamically load some of them. This will enable more flexible and testable code.


Learning all the subtle differences between the sub-topics of Dependency Inversion, Dependency Injection and Inversion of Control will enable you to confidently apply dependency management in your UI apps.


So, this module takes you deep into;

  • A clear definition of the problem of dependencies in general. Then why you need to understand them perfectly before moving forward
  • How to use TypeScript interfaces and understand the biggest power of strong typing
  • The sort of problems you will face in scaling your app when you simply rely on normal module loading and do not centralise your dependency management
  • The difference between functional and object-oriented dependencies
  • How dynamic dependency strategies work in general
  • What an IOC container is and why one is critically important in a UI app
  • How to build your own IOC (Inversion of Control) container to see how they work (this makes you better at using them)
  • Connecting the dependency management lifecycle into the lifecycle of your chosen UI framework

In training slide...

Module 11: Abstractions

Do you dream of being able to create a multi-level, location aware, and configurable navigation menu and sub-menu-system, driven by simple JSON that works on both desktop AND mobile screens WITHOUT having to duplicate HTML?


No?


Me NEITHER!


Pssst, only JOKING 😃


That's exactly the sort of power I want in my UI apps!


If THIS is the sort of power you also crave, then don't fear this module... ABSTRACTIONS is what you need!


Everything you have learned so far has been helping you connect up the major architectural concepts in your UI app confidently. But you are going to need to manage some 'cross-cutting' concerns too. For example there are common features that almost every UI app needs; such as routing, navigation and 3rd party controls.


At best engineers tightly couple these concerns to the wrong places using the wrong interfaces. At worst they don't even have a design which defines them in the first place! They just bury these subtle but HIGHLY important abstractions in all the other parts of their app, like in-the-markup, noooo....


So, in this module we teach you how to interface your highly scalable UI architecture to all the cross cutting concerns. We do this by ABSTRACTING them into clear and unambiguous patterns that... WORK. We are going to tear apart your very real integration concerns that you WILL encounter in the wild, we cover;

  • The very important difference between view routing and application routing and where React, Angular and Vue fail to naturally insulate you from this oversight - but what you can do about it
  • The theory behind routing abstraction and building applications which are navigationally 'aware'
  • The pitfalls of static navigation and why you shouldn't use it (especially in responsive apps)
  • A decision making matrix to help you choose the right navigation 'abstraction'
  • The 'proper way' to implement 2-way binding at screen level
  • How to build contextually insightful screens with 'polymorphic' presentation concerns; helping you navigate your own screen design easily
  • How to fluidly and safely integrate 3rd party tools into your app, so you can communicate with them without falling foul of 'their' lifecycle which can conflict with yours

Module 12: Final Project

By this point in the academy you have now learned all of the foundation and critical knowledge you are going to need to confidently tackle and architect complex UI apps!


But your work isn't done until you have completed a 'final project' where you will holistically cement the knowledge you have learned so far! We have designed this final project to give you exposure to all the interlocking concepts you need.


In this module we will complete the 'Books and Authors' sample app by going through 4 stages together and building it one stage at a time.

  • In part 1 we lay down our application 'wireframe' skeleton where we learn to plumb together our Fast-test architecture with all of our 'abstractions' that will power navigation and routing
  • In part 2 we start by using Fast-tests to flesh out our first feature 'Books'
  • In part 3 we will then begin to chip away at our aggregated repositories for books and introduce authors, you will make a decision on how best to model the problem using the visualisation process we showed you earlier in your training
  • Finally, in part 4 we will connect up the 3rd party controls to our Fast-test architecture assets and you will see how to make this work with everything else

Battle-Tested UI Architecture Methodology

Anyone who has ever trained with us will tell you we are different to most coaching companies because we do not claim to be ‘Gurus’.


Instead we teach simple ways of doing complex work that are not based on theory, they are based on the battle tested experience of real projects that our company does commercially!


Yes, that’s right.


Myself and my team use these techniques that I teach on actual live projects for companies that we consult with.


This means that you are not gaining information which is based on subjective opinion but on the hard-learned lessons of commercial reality and real case-studies.


This means our training is simpler because we don’t have time to teach our clients pointless theory when they have actual deadlines to hit.


This means you get results first not theory.

Weekly Coaching Calls (Currently 7pm UK Time)

What is the biggest barrier to learning something new?

It's easy to buy a course on Udemy and
file it away in your todo list (never to see it again) but if you really want to succeed in life you need a 'coach'.

The
secret sauce at Logic Room is that our content was put together by people that actually use what we teach every day.

So you will get
personal access to our coaches every single week! It's super easy to do you just join a call on Zoom with us and we will do a deep dive for whatever you need from us!

This means you will not have to worry about
struggling to integrate your very real production concerns, or architectural challenges ever again.

You can ask our
experts anything; you can even ask us about leadership and building the team of your dreams!

And don't worry if you can't make the call simply send us your questions and we will record the answer for you to pick up at a time that is convenient!

Testimonials

Javier Valderrama

Principal Consultant @ Endava, 10 years

“It’s like a recipe … you can have all these ingredients ... but the right master is the one who knows exactly how to combine them.”

Mohamed Sallam

Software Engineer @ Framer, 5 years

“The course takes a very practical approach ... The value you take out of it is comparable to having your own mentor … I highly recommend it!”

Laurie Eshleman

Web Developer @ 101 Solutions, 2 years

“I now see a path for setting up my applications so that they can be tested thouroughly and without the need to completely re-write the tests when the application grows/changes.”

Frequently Asked Questions

Can I learn at my own pace & when do I start learning?

There’s lots of content but to avoid overwhelm (the biggest reason people fail to complete their learning and potential transformation), we give you full access to the smaller courses and the first sections of the core UIAA programme and then we drop in one module a week of UIAA for you.


This is intentional to ensure you take your time to truly understand the principles in each module, do the exercises and get to grips with the core concepts before you move on.


UIAA isn’t a quick 2-hour udemy level course, it’s much deeper than that but by investing your time into it, you will be rewarded with the knowledge to build scalable UI apps in whatever frameworks you choose in the future using this exact same battle-tested approach.

What time commitment do I need?

The core UIAA material will take roughly 60+ hours to complete.


Suggested route:

1️⃣ Start with Scalable TDD Course

2️⃣ Then React Quickstart (if unfamiliar)

3️⃣ Then UI Architecture Academy (UIAA)

4️⃣ Then Decisions for Software Engineers

5️⃣ Any Monthly Challenges/Exercises


Don't forget you can post your questions in the community and/or on the group coaching calls.

Where is the coaching and training done?

The course is remote, you use our platform to get lessons and material and then we have group coaching calls which are remote.

How do the remote coaching calls work?

We use a platform called Sessions currently. You can post questions before the group call if they are complex so we can investigate your questions in depth with you.

When does the coaching start?

The coaching calls are currently every Weds at 7pm UK time. So as soon as you enrol you can join the next call for your introduction to the rest of the group. Don't worry there are transcribed replays if you can't make the live calls.

How long do I get access for?

On the monthly access package, you will have access to everything for as long as you have an active subscription.


If you prefer to have lifetime access to everything, then you can take up our lifetime package.

What level is this for?

You just need to know JavaScript, ideally up to version 8 (ES 2017), but we teach you 'consistency 'in your approach first...

So, you typically need to know less than you do with other training or bootcamps.

We use React but examples are provided so you don’t need to be a React developer - just know and be able to use JavaScript competently. We also give you a React 'bootstrapper' training module as a bonus to help you get enough to use the concepts in your production apps.

Which frameworks and languages do we use?

Version 8 (ES 2017), Jest and React to demonstrate the techniques and give you exercises.

The techniques are 'framework agnostic' so you can begin using them in any app using any framework (Angular, Vue, Backbone etc).

What are the requirements?

Just a modern browser – nothing more. It’s all 100% cloud based, you even get your own online test DB. You are able to reset it too.

What Is the difference between this and Udemy/Pluralsight/Front End Masters?

Sometimes engineers will ask what the difference is between our offering compared to other training websites.


UIAA isn’t a quick 2-hour course like those you might find on Udemy. It’s much deeper and more comprehensive. By investing your time into it, you will be rewarded with the knowledge to build scalable UI apps in whatever frameworks you choose in the future using this exact same battle-tested approach.


Unlike many other platforms, UIAA provides ongoing support through weekly coaching calls, an active community of over fellow students, and direct access to expert coaches. This level of interaction and support helps you overcome challenges and accelerates your learning process.


While many courses focus on specific tools or frameworks, our approach is to teach you principles and techniques that are framework-agnostic. This means you can apply what you learn to any current or future frameworks, ensuring your skills remain relevant and valuable.


Our curriculum is designed to equip you with real-world skills that you can immediately apply to your projects. You’ll not only learn theoretical concepts but also how to implement them in practical, scalable ways.


Our program is intentionally structured to ensure you master each topic before moving on to the next. This methodical approach helps build a solid foundation and ensures you can confidently apply what you’ve learned to real-world projects.


How Easy Is This To Use On An Existing Project – And How Will My Team Adopt It?

This is a great question because this is exactly what our approach is designed to do – to be integrated into your current codebase by you and your team (with us coaching you and you coaching them - step by step).

The academy has 24 battle tested exercises that represent the specific UI Architecture challenges you will encounter – you also get 4
Accountability exercises on top; these are practical hands-on challenges designed to get you taking action on your current project and getting full team buy-in (you will learn to influence and sell the underlying principles that we teach you).

Typically, our students will want to get to module 4/12 (The Anatomy of a Complex Test) before they feel confident enough to branch and refactor code into the architecture they are learning. But the reason we give you group coaching and mentoring is so that we can help you move at the speed you want to in a low-risk way!

See a review on this page from Fred Linqist who became a tech lead after studying with us and integrated our approach into the entire company stack with 15 engineers

Me or my team is not using React or Mobx, does the approach still work?

Yes! We use React and Mobx but you will learn how to port the specific framework code we write over to your chosen framework (React, Angular, Vue, Redux etc).

Does it work with the 'backend'?

This is a coaching programme designed for frontend engineers. Typically our students get most benefit by putting the techniques into React, Angular or Vue apps.

However since what we teach is broadly about good software engineering principles you can adapt many of the patterns on the backed also, but you would need to work with us on group coaching calls for specific advice on backend tech like Node and NextJs.

Does This Work For 'Testers'?

If you are a manual tester then no, the academy is not suitable. However if you are interested in learning to create deeper integration testing at the code level (taking a technical approach to testing) then the academy can help you. But you need to know JavaScript and have experience with it.

Is There A Money Back Guarantee?

Yes, you have 14 days from starting to ask for your money back if you are not happy and we will refund you!

Transforming Software Engineers into UI Architects