Author: sachin dixit

The rise and rise of salary offers

If you read popular news articles in India about IT, your would get a picture that everyone is changing jobs .Lately some media house have also started talking about the hikes and how big they are .A lot of these construe that due to covid19 people dint get hikes and now the jump ,or something on these lines .

Enter LinkedIn posts and you see lot of youngsters posting about how they got some offer and they manger to outgrow that with counteroffers .The percentages are huge .

At the same time ,the business newspapers and quarterly results hardly talk of huge contracts coming their way. How does then one connect this and form the coherent picture ?

The dollar peg of Indian IT salaries is off now

In a globalized business it is hardly a surprise that exchange rates come into picture when deciding employee salaries .However in the initial decades it was the IT services that defined job market. It also brought billing rates with it .The rates were ,generally linked to roles and designations . It also meant the hikes and promotion were aligned to annual results and big hikes came your way when roles changed . This is so fundamental to us that our hiring-retention discussion still center around this .

It is not an exact year but around 2008ish is when the captive unit movement started in India. This was first instance of that billing rate foundation was shaken .More or less .But the exchange rates still remained in background .

By next 10 years .To put a precise date , around the time Flipkart and Ola happened in India we had mass scale recruiters that the foundation of dollar peg was taken off. The more and more build for yourself software companies open here, the more prominent this trend is .

Covid19 or Buzzing startup : Where is the tipping point ?

Of course the startup scene in India is maturing .Do we then conclude that this alone is causing the scale of salaries in job offers to rise suddenly ? A buzzing economy does cause good hikes in salary , we saw that in 2003-2007 . So does post social shocks , like the hikes in 2011-2014 era. But that does not explain the suddenness .Nor do LinkedIn posts mentioned above say that everyone is jumping to startups .

It would be useful to consider other social-human aspects that covid19 brought to us.

1. Onsite is less lucrative : The main hidden attraction in services companies was onsite posting .Covid 19 has made it look less attractive or even bad choice . So any market worthy candidate is now forced to discover his native-local worth .
2. Subtle Social pressure is off : In absence of a survey , it would be difficult to guess the contribution of office atmosphere into long stays at companies .But this is important factor why people stay .Your friend circle ,the lifestyle keep people hooked .In some cases an inspiring or imposing boss contributed . In some cases your yesterdays bug or mistake made you push thinking about career to next day. And the main factor is formal arguments .There are many formalized workplace related arguments and anecdotes about satisfaction ,purpose and all that worked in formal work place .A lot of them meant different thing when you sit at home in lockdown. In some cases people told me they laughed at these stuff now.
3. Family time reality check : There is big value that we attribute to continuity. This is one invisible force that keep people into same circles .In many cases semi urban rural families thought greatly of the work, workplace, companies .Working from home brought the reality check .The long calls ,shouting bosses and hours of hunch back coding on sofa looked different to them .Of course some must also be touched by care shown by companies during covid times .But the rosy picture that you have a IT-working kid that is very attractive in marriage market is realistic . The cost of the salary is obvious to them now. In some cases either families or individuals also got space and time to consider alternative careers .

All of above factor lead to an individuals who are well reflected about basics , bolder about their demands , gusty about the bargains demanding sharper differentiation . The LinkedIn post you see about counter offers are from such people who have market value !

The aftereffect we need to be aware of

My old friend the other say forecasted that this trend will not sustain .As of there is some alignment in poverty and forces of nature .One even said that later these companies will fire them or give 1 % hike .Any such comment ,reasonable or not misses the fact that hiring companies are also rational actors.

When we postulate that dollar peg of Indian IT salaries is off ,we must also consider that the talent peg is now global . Increased remote work and more startup had to have this effect. So the net result is that not only salaries but the skill demands are also catching up with global peers (emphasis is on skill demands as opposed to skill levels).

This is not to say that local talent was lesser .It is just that both factors are in sync .Looks like they will remain in sync. This needs some consideration by career minded people .

When we talked of billing rate dominated -pyramid workplace .We dint talk of a work place where skill levels where matched to client needs .In many cases the skill range was narrow ,in some cases it was not latest and in some cases it even allowed people to hide behind the pyramid without having good skills .

The movement from waterfall to agile in many cases exposed this .It is thus no wonder that agile and reskilling became buzzwords around the same time in India .How ever this far the the skill demands and salaries where not rising in sync.

I would like to postulate that now they are .This means that not only the skill levels will have to be globally competitive but also that the onus will now be more on individuals to stay on the edge of competitiveness .Proven and impressive hands on skills are already the norm in Indian IT hiring .This might also get into zone of industry leading talent levels .If the salary curves are to sustain and grow across years , aspiring candidates might be also judged on their tech-though leadership . Say open source contribution or patents or research papers would become norm. Ones teaching technology on professional platform or with books on their names .Even difference of opinion on established technology norms count as positive !

All of this is actually is good news for the community as well as the industry and the individual .We are looking at fitter techies who are well paid, can lead the agile trains, deliver industry leading work. Its win-win-win .

The only looser might be candidate who think that they are outsmarting the industry by squeezing the “hot market”.

In reality there is no hot market .All we have is market demanding top skills and able and willing to pay top rupee for it .Have good next decade Geeks !

Of course, each business newspaper is telling you that attrition levels are high in so many IT companies in India .One gets to see huge percentage numbers cited in such news . But very few of such news present the the details of such movement leave alone the causes . A few article and posts did mention that last year due to covid the hikes were less or nil . But does that qualify such big jumps in attrition .

A deeper discussion with the folks exiting tells diff story . In some cases the women have realized ,after staying with kids for a year that their IT job is not that “needed”. In some cases the men have questions need of an IT job itself for livelihood .In many cases a lot of folks I talked to had farm or fathers business as a fall back .And the covid wfh allowed them to consider going back seriously .In some very sad cases ,friends had causality or very bad episode related to covid which made them question the need of city job away from near ones . A few youngsters told that a year at hometown they would do a start up because a formal IT office doesn’t excite them now.

Of Course mine is not a detailed study with lots of data .But it should tell that there are some fundamental shift in Urban-9.15hours-IT jobs that were seen as the thing in India for past decades .One might read some US based publication and call this quit job movement but that would be superficial .I would rather call this as reverse migration or some sort of coming full circle on Urban migration as option and IT job as the best lifestyle choice .Both have been challenged by covid. So next time someone says the people are jumping jobs for money , it might be t he symptom but the causes might be disillusionment .Oh and by the way you where thinking of allowing your team to work 2 days a week from home, right ? Welcome the HR challenge of the decade .

The paradigm has ,in this case ,actually shifted and we don’t exactly know where 🙂

Lead question : Why API First

Ask a product manager what is the different between made or order software and a product .He will tell you how product is general purpose for the given domain (not generic tough ).How it captures a broad set of use cases from the domain .How it is flexible in adopting to diff combinations of rules that are included in these use case .How it is future proof and is ready for future changes in domain .How it benefits from vast experience from we have in the domain/customers /consultancy . It goes on .

Yet when it comes to day in life a of developer he is often made to code first , code just what he has been asked for and ship it . It is obvious that a start up will only put coding effort into what sells but should that rule apply  to the very definition of the product as it is conceived  ?Is defining a product/service/roadmap same as coding it ? Such gap between what is “Seen” by product and what developers are made to do are solved by evolution read software design . API first is a prime example of being comprehensive and thus evolution ready yet riding the demand wave frugally .

Business scenario for  API first

• Integration /Consumption : Software need to be integrated by different parties as the success happen .Would you like to struggle to meet demands of this success come your way ? or would you like to be ready for it with some top-up effort .The answer is in thinking API first . Once you  think of well  thought of APIs  gluing them become easy and future successes becomes faster . This could mean integrating in or integrating out ie consuming (and monetization ).
• Aggregation/federation  : The internet economy of aggregation made famous by amazon/uber has made clear a case for softwares co-operating with each other .This increases market reach and revenue .However aggregation economy is volatile and competitive . One need to be ready at shorter notice than typical integration projects .The integrations also need to be robust for the parent party (and their customers ) to trust you .Another flavor could be federation of services amongst equals . A well thought of API on both sides make such integration easy-fast-reliable .
• Extension  : Acquisition ,Saas enablement  ,inhouse aggregation(called integration ) or even customization are typical cases of base capability of software being enhanced by extension .We may thinking of moving from web to mobile to chatbots/alexa . We may also consider taking base software and enabling that as multitenant offering .  While these extensions are value positive for every one they need be very liberal in capability but restrictive in scope .This help us keep sanctity of base software  yet allow creative but reasonable value add . An API layer will clear laid out  extension helps .

All of these driver point towards one fact that business that are built with well defined contracts stand to benefit from this opportunities as opposed to software that are inwards focused and need extra work for any opening up .While this discourse underlines that API first help us with readiness in terms of external forces , the same game plays out within the teams also .It is just that inter team play is seen in the light of following themes

Advantages of API first approach

1. Domain fitment : The tendency for Business analyst and developer to grab a piece of functionality under discussion and “just code it” .This has huge chance of teams creating code that is few layers higher in domain and miss out in fundamental building blocks .An API first approach also forces teams to think bottom up inside the domain where they are made to think of the “built up” of the functionality .This ensures that the domain of software in considered in totality before team chooses to pick up one slice of it and code it .
2. Parallelization : API also stand for clear contracts .So it allows teams to do more parallel work as api-first minimizes risk of large scale integration of parallel work streams .Productivity and time or marker related gains follow .Agile ie .
3. Testing : Since APIs are laid our clearly the function or security test team get more and enough time for deep thought testing approaches at all levels of test coverage .
4. Functional resilience : Since API commits to a final contract it gives a robust functional capability which is strength .At the same time there are many internal implementation details are that are open to amendments which adds to overall resilience .Think of a case where old rule based API is replaced with new Machine learning based API ,while the API is same the quality of algorithm is smarter .
5. Evolution : A well laid out contract also facilitates future evolution easy .It could be new version , a customized or localized flavor which offers changes in the same neighborhood as original older version of API (hence evolution ) . This however needs a better governance put in place .
6. Tech Debt repayment : A well defined contract also allows decoupling between team producing it and team consuming it . This allows the team to keep on changing internal technical detail of their API healthy and repay tech debt without disruption .
7. Other than code needs : There are many other than code needs like performance ,build , documentations , availability  , monitoring ,audit ,security which are get into motion after the software is committed to repo .API first lays out clear shape of the software to be and allows these team to think thought early on and facilitates these other than code needs at much deeper level of engagement .

Pitfalls and background of API First

API first is often confused with webservices .This often leads teams into thinking that if they are not exposing any url style webservices to anyone they are free .A better term for API-first could be contract first (but that’s very technical world so API is used ). This means that no matter whether one is creating piece of software that is consumed by outside world or other teams/developers in your company ,so long there is interdependency one need to commit to clear contract .And in order to see the gains of agility etc one need to commit to this contract first .This also means that all layers of software from external facing UI -webservices to components-frameworks in middle layer till data-integration layer one need to think  of defining clear contract .To that effect every component is an API that is producing or consuming other API . Even so-called cross cutting layers like logging are mater of laying out clear cut APIs.

The concept of defining clear interfaces in now new to programmers . We often talk of specifying clear interfaces and programming to interfaces .However this good practice start at individual program and ends at design patterns . May be it is seen as something only serve side programmer do . But , as we approaches more layered , more distributed(teams as well as software) , more integrated and more reusable (think open source ) , more componentized and so on the value of clearly laid out contracts between these seams is apparent . API first is this a mainstream realization of this fact , tough people confuse API with webservices only .

more reading ,Bezos Amazon API Manifesto and link to Yegge of Googles Rant : https://gigaom.com/2011/10/12/419-the-biggest-thing-amazon-got-right-the-platform/

T recruitment in 2020 is living in Full (stack) paradise. If you are into the junior ranks which i.e anywhere less than 8 years of experience then Full stack is your zone. At higher levels, it might not be part of the designation but its always implied. But at that level, you are way better “experienced” to handle job and career .So this post is focusing on Ture Full Stack Developers (TFSD, a term which if not coined already, might become reality soon).  

The ask: Full Stack Developer (FSD)

The most popular description of FSD is a software engineer who can do backend and frontend, both. An alternative description is that FSDs do client-side and server-side development in addition to database work. In specific you are the one who knows to :

• Work on UI  
• Work on services 
• Work on data storage 

Based on your IT stack this could mean web/mobile/desktop/low-end IoT displays for UI, some combination of web services/streams/security backing it and at minimum a database/cache/session working across.

Benefits of FSD 

For startups, this offers a sweet spot. We can work with smaller teams of talented engineers who can do the “whole thing”.Often FSD also leads to complete ownership of the “whole thing” to a developer. Which is why most training plans for entry-level engineering talent are Full-stack. In fact, it also expands to some orientation on OS, UX, network and so on. Rightly so. A good breadth both in training and work exposure is good for engineering organizations. Except that it is a means and not an end.

From Full-stack to Fools Stack 

Proficiency, expertise, and words like them are used in Job Descriptions(JD) of software engineering to imply a good quality of depth. Except that it should be Full-Stack. That’s asking “to have great depth across the breadth of the technology stack(we use)“. This is not asking for specialist developers with good breadth. This is asking for a specialist in everything! 

We even have cute words coined for them, LAMP-MEAN-MERN and so on, signal this very thing. And it works. 

The hidden fallacies 

Developing a liner flow of requirements fits naturally to how we think. We start doing one thing and can finish it well. The same linear flow can be coded full stack – end to end. Except for software development ,it doesn’t remain linear. Functionally as well as technically. The lines cross, merge-diverge, conflict and suspend. This needs specialization. If your org is working well with FSDs then you are sure to have these specialists hidden (and operating and sustaining your FSDs). 

Some examples. On an agile task board, the UI development might look like a diagram that needs to be drawn on a device/browser. But it also involves lots of animations, offline ability, support for disability norms. We have to also make sure that the components don’t make too many server loads and it needs to handle clickjacking and lots of web security stuff. And your business user also wants a responsive web design where the page supports text entry on full form but falls back to toggle on smaller ones. And yes we need to also support integration with the camera. And yes lots of browser types we need to support. And yes it will be great if somehow we can also make it work(render) on Alexa show or your watch.

These are not very unusual or problematic requirements. But they are so specific that one cannot handle it without going deep into core issues like HTML/CSS/HTTP/Device or delegating to some specialist.

The same can happen to your back end. We can start with some combinations of REST-microservices. And you need to also work with auto scaling design, support distributed commits, comply with tracing, also use some queuing. And we also need to support headless mode for some peer to peer calls. And some batches also. And some of the data can be binary. And we need to also use API gateway/service registry. And also support multiple service versions.

We could go on writing the same expansion of depth for the data side as well. All of which/this is not unreasonable. But taken together this is a lot. And we also expect the developers to understand and model the domain wisely (along with their tinder and insta 🙂 )

Yet we see neither FSD’s complaining or projects failing. For 3 reasons, I say.

1. People are more talented than the slice of intelligence we pay them for. So they pull it off.
2. This pull off is at the cost of some other super developer or their own passion for something else.
3. The technical debt and bugs it creates are not accounted for in the delivery/shipping based criteria of the project’s success.

Why FSD is hard

In the time where I started my career, we used to call them technical architects. These were little experienced people who happened to work across the application and managed to retain the skills acquired. It took them time. But they had stronger grip and wiser intuition of it all.

Most of the JDs we see for FSDs are 2 to 5 years or similar experience. But FSD is hard due to multiple factors that play out.

We are coding to frameworks

If you the FSD JD’s they are full of frameworks. Frameworks are great in abstracting problems and offer a great productivity boost. But they don’t eliminate them. That’s the nature of an abstraction. In IT projects the fundamentals of technology, as well as design, show up unannounced. This increased workload is not factored in the FSD world. Not only does it cause increased workload for Jr developers but it also kills their opportunity to have a detailed understanding of how the framework builts on top of the underlying technology, the choices it made, the problem it solves and then ones it skips.

You mistake layering for the stack 

If we carefully analyze the full stack it closely aligns with how the projects architecture diagram looks like. Often the full stack is vertical slice of this diagram. What is, however, missing is that your diagram skips lots of techo-framework details due to its 2D drawing nature. Security, Monitoring, Deployment, Packaging, Scaling, Performance, etc. are part of the work in equal measure which cant be completely kept separate from Jr developer’s work package. And did I mention the design principles, process, testing, and documentation?

While FSD style hiring can give initial relief on staffing, we are greatly missing on maturity aspects.

Your stack is not alone

Oh yes, Unless you are a startup building the next uber/google/amazon or what it is. Your stack is not alone. There are always some enterprise systems that we need to integrate with. Some SaaS-based products, a BPM, an ERP, Rule engine. Some schedulers or some in-house “stuff” that is recommended as a norm.Or at least AI in included 🙂 . New hires are lucky if they are told about this with JDs.Often this is missed and needs to be paid for later, somehow.

Developers have inclinations

Each developer has its own inclination towards soft aspects of technology. A UI developer often called as frontend developer can intuitively realize the event-based nature or the aesthetic pleasure of laying out and the experiential nuances (UX) and pursue it. A server or DB side developer might like the notion of event sequence and the time-space nature of their work and hover there. And So on. May be younger developers are not able to verbalize it well, but when an able programmer says he enjoys it(his work), the reason is not comfort-zone but the sense of joy he gets.

The problem FSD creates for developers 

We can go on about structurally how FSD misses on lots of aspects of the actual work conditions and how it needs to be paid for later by organizations. But the developers who manage to pull of FSD tag for years have a lot waiting for them also.

Stack Stress

The frameworks change very fast. It’s very common to get a new version of your tool every 6 months. Some times the changes are also breaking. Taken together, full-stack. This is a lot to cope up with. On top of it, your project might not even choose to use the new thing. In which case the individual need to figure out how he will keep updated.

Dwarf experts 

The world is full of great brains. Brains that can pull off all stack development and brains which are truly masters of all parts of the stack. I love to work with such brains.

But are they so common? If not, then as the industry we are pushing the teens to war without letting them develop a deeper understanding of tech.

Resume driven development 

How ready are you to recruit a great swift developer for nodejs project? or an angular developer for React ? or hands-on Unix admin for Kubernetes?

The answers that we get from the hiring community and mangers are not encouraging. Everyone wants a perfect fit for the project without realizing that we are breeding disposable developers. But the developers know this intuitively. And they fightback. With resume driven development.

The greatest and shiniest thing has to be on one’s resume or we are willing to change the tech stack/project/company. (If only we were paying them much higher for such disposable hiring ).

Joyless Work 

Given the target of FSD hiring and this post is below 30 years developers. This is a major factor. The FSD hiring movement doesn’t talk of development plans, career paths, mentoring models or code retreats. We instead have hackathons, reskilling, upgrading. We have even stopped talking of reading long format books on our work area .The buzz in skills development is all the online courses. If we ask other arts professionals, the fundamentals give them joy and the latest style and trends let them keep their jobs. The FSD movement in S/W misses the technology fundamentals part.  

And I am not even talking why they also need to code on algorithms and data structures in their first-round(what a nuisance of proxy it is for talent) 

The Way out

The way out is to train them across the pyramid and be candid if FSDs mean disposable recruitment.

So much we talk about how fast the landscape is changing for technology professionals it is not the reality. The underlying technologies that drive our tech stacks change in span of multiple years. It’s only the stylistic solutions based on them change. Even then we often see these frameworks use designs and techniques from the same neighborhood. A very terse list [(System V to VMs to containers),(make-maven-npm),(taglib-web components),(grid computing-bigdata)(DW-ML)].

My approach was to always train them (or make them self train)on how the framework built up happened. This means knowing the basic technology in its bare form. Knowing the significant earlier attempts in the framework space that existed. And then training them the given framework. The same approach was used for the so-called tech stacks we had in our projects. We also exposed them to wider QoS needs that the frameworks might miss or partially cover. And the standard design approaches in S/W. This allowed them to see through the stack. This not only allowed them a great grip on them but also the new changes in these framework/space did not cause surprise.

I have been working in architecture teams.The examples I give here took anywhere between 3 to 5 years to train a good developer across layers and components of the products. These were also full-time direct reports. (often our mentor relations will continue across companies).

Chances are that the developer you are recruiting as FSD has done this/similar approach on his/her own. (S)He has also done the hard work to read a lot and do hands-on work. And will have to continue doing so.

But we must pay them well for this hard work and the tough job of keeping up to date. We must also realize these are the folks that seek joy in their work on the lines of a craftspeople and have different self-esteem than usual. Handle them well recruiters….

(and to these folks…I will welcome you all to the technology architect community soon, unicorns 🙂 )

if we take word cloud of all the design discussions a technical architect participates in (or made to participate in ) generic solution would stand out as one of the key term. Be it a waterfall process or an agile one or even appraisals.

The claim is simple. There are multiple things that need to be done in an IT scenario and there is a generic solution that takes care of it. It is often also a direct claim to some efficiency or effort-cost saving. Which makes it very appealing in meeting rooms and is often makes technical people trip (the verb). Often it is not the case tough.

if we take word cloud of all the design discussions a technical architect participates in (or made to participate in ) generic solution would stand out as one of the key term. Be it a waterfall process or an agile one or even appraisals.

The claim is simple. There are multiple things that need to be done in an IT scenario and there is a generic solution that takes care of it. It is often also a direct claim to some efficiency or effort-cost saving. Which makes it very appealing in meeting rooms and often makes technical people trip (the verb). Often it is not the case though.

Examples of Generic solution claims 

In the era when NoSQL DBs were all that buzz, I was reviewing a generic solution that would allow connection to all types of DBs.What the solution claimed was that between relational and different NoSQL DBs the way to connect to DB was different so a generic solution was build to handle it. To the experienced eyes, this was actually a common wrapper for various DB. Internally there were factories that were forced under a Common Interface. And not to say a lot of IF-ELSE around DB_TYPE flag and so on. It wasn’t objectional as a proposal except for that claimed lot of savings and fell apart when DB specific constructs were to be handled. And DRY of what was in the field already.

Another example was when we were doing REST. This was more than a decade back and lots of legacy code existed with us. Again a generic solution. This was, hold your breath, a generic REST service. The claim was that is more effort efficient! This generic REST service would expect service name and all parameters in the header and a generic service message body. One needs to then just write specific handlers and bingo lots of effort saving. It was a long struggle to convince the involved that this solution folded the URLs into headers and the effort to write service related code was still there. In fact, the enforcement of generic had increased the coding work. Not to mention it had killed REST.

I had seen multiple variations of this. A generic integration toolkit for service integration. A generic authentication manager.A generic message parser, a generic webpage, generic deployment tools(cloud + bare metal), generic build tool, generic log. Invariably it would be some combination of factories-command-strategy that missed the essential complexity of specific processing and claimed to be a faster way to project success. 

How to evaluate such claims?

Given that most of such occurrences missed the same points, I use the following line of probing when I was to approve-review the designs.

1. How did it handle the differences? (of whatever was summarized as generic viz different formats, protocol, delivery mechanism, etc. The answer would invariably be to write code to handle it )
2. How would it communicate the different types of errors? (many times this would be a total miss or some generic error wrapper that needs to be parsed by calling party)
3. How did it cater to the conditions that apply to the execution flow? (it would be either missed or one need to write code or sometimes a domain-specific language ie DSL was to be used)
4. Does it/have to maintain some sort of state or stack in order to finish the execution? (this would expose deeper design flaws )
5. How much effort would it take to add a completely new variation of specific to this solution(again a very fair question that would test the robustness of the design)

I would specifically not ask whether such a solution exists already or can we open-sourced it. The fact you are in this situation means the point is lost. I would also not ask which all design patterns apply which when answered would offer false proof of validity. The intent was to do a fair assessment and check if the generic solution discounted the specifics.

Invariably the generic solutions had missed the complexity of the specific and claimed that because it has been wrapped -it doesn’t arise (and hence the savings ). Gradual questioning like this would uncover the effort/processing complexity. This often leads to the generic solution giving space to rightly estimated solutions that represented the real depth of the complexity.

The positive side 

But there is also a positive possibility. Sometimes there is a real fitment that exists for such adapters(a very broad range I cover with this word). An expanded version of the above questioning makes the design specifications deeper and allows the team to correct the course. The example in the above list where a DSL was proposed to handle all common tasks applicable to our problem space was indeed a good solution that offered effort saving and also empowered the developers. We must also note that in such cases the correct term would be general-purpose as opposed to generic. It conveys the trade-offs neatly and effort aspects transparently. 

In another case mentioned above, a generic webpage solution was offered. This was basically a wrapper of HTML and JS that could handle a number of UI related needs we had. One could argue (and I also had my reservations)on merits creating markup language for markup. In the era where componentized micro front ends are proving to be practical, we could have dismissed this solution. In my case, we stressed it on the team that this is not a generic solution. It was, in fact, a templatized design-solution. This made the team aware of the enormity of the claim but it also allowed the respective scrum teams to make their choice if it really fit their scenario.

In cases where I had more control over the teams, we also used all such submissions of the generic solution as a training opportunity for the architects. It would often be contrasting their work with existing tools and frameworks in the mainstream and whiteboarding on how all their solution could evolve to a professional level.

But that’s about a positive spin. The appeal of generic solutions in effort discussion has not reduced….. I hope this post helps you with that somewhat.