Technical Debt Puns

I started a new job a few months ago and I'm finding it tough to navigate within the team.

The codebase has quite a lot of technical debt. My manager acknowledges it but refuses to even consider fixing it. He's too busy creating busy work jiras and trying to get as many of these closed within the sprints.

The rest of the team knows there are things to fix as well, but they are "too busy" with business deliverables to consider it.

The thing is, if we fix the technical debt, we should be able to deliver even faster.

Here are just a few issues with our project:

• Monolith repo. It should be split out into multiple repos, but somehow there are several projects all living in different branches in this mega repo. Problem is that master is very very old and releases are never merged into it. Even if releases were merged, it would be difficult since I said different branches for different systems live in this repo.

• No Unit Tests - I mean none. This could also stem from the fact that there is no DI (next issue).

• Lack of dependency injection - every object is created within constructors. Some developer looked like they tried to put in a form of dependency injection but ended up just creating a service locator pattern.

I'm thinking of just quitting because I know I won't be happy if this situation won't be resolved, even slowly.

Anyone run into this kind of situation? Any advice would be greatly appreciated.

Have you ever played Jenga? It’s that game where you have a tower of blocks, and you have to carefully remove one from the tower and place it on the top. Then eventually you remove one that’s too important and it all falls down.

I work in software. I’ve worked on what feels like an uncountable number of projects over the last decade or so. I’ve written in comments about technical debt before, but I think we are now reaching ‘peak debt’.

Technical debt has existed as long as software has existed. And in a way any system has a level of debt owed when compromises are made. How that debt is managed is what makes a great project manager and a great team. If you’re not familiar, technical debt is the product of trade-offs made when developing software. It is the cost of work that must be done later when choosing an easier solution in the short term.

As an hypothetical example, imagine you’re writing the code to determine whether or not you can take off your helmet. In space, this is bad and should not happen. But inside a space station or on a planet with breatable air, it can happen. The problem is that writing an entire system to determine if the environment you’re in has breathable air is going to be a massive project in itself, and you’ve just been tasked with making sure that the helmet can be safely taken off or not.

The short-term trade off is to find ways that make it work for now. For example, you never spawn in a non-breathable environment – this is just how the game works right now, so you can safely assume that when a player spawns their helmet is off. So the default setting for the helmet can be set to ‘off’ and the default setting for the ability to take the helmet off is ‘yes’.

Next, with the limited number of locations around the map where you pass from one environment to another environment, you can simply attach the change to passing through that area. Add a box to the exits that sets the ability to take the helmet off to ‘yes’ and ‘no’ depending on which side you exit. Attaching further code to force the helmet on based on this would also be fairly easy at this point.

As far as anybody playing the game knows right now, it works. And if the game stopped being developed at this point, nobody would ever know this is how it was programmed. Software is programmed like this a lot, because the cost of writing that behaviour is perhaps a couple of days, whereas the cost of building a system to actually simulate and understand breatable environme

Hello,

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade; we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen firsthand how this impacts engineer productivity and morale, and at the end of the day product delivery.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

Caribou in action!

I work in an environment where we code review and unit test to 100%. There isn’t too much tech debt. Im actually wondering if we should allow for MORE tech debt, the more benign kind at least. My reasoning being, if you’re working on a product that is still in a pretty evolutionary/prototype stage, there’s a chance some of your debt will be “wiped out” so to speak if you need to go a different direction design wise. In our current state, it’s hard to really trim fat since it all needs to get done, so the pipes can get clogged with cleaning up code instead of actually delivering value. I feel as though there is a balance to strike that varies based on the project type and lifecycle stage. What strategies have you used to strike this balance? When was carrying tech debt a good thing?

To me, it’s all about priorities. If you defer benign tech debt, you might be able to unblock a dependency of that system, work on another feature, etc. This seems like it could get out of control at some point though, so im hoping to hear some war stories/general strategies used.

I came across this in r/ethtrader but I think it's relevant here. I believe that SmartBCH is more efficient than Ethereum in ways that Ethereum can't easily copy. But if you asked me why, I have do admit I don't really know. I do believe that Ethereum is like a ship that's too big to turn around, ie, I believe that Ethereum has insurmountable technical debt. But does it?

This video asks, "What technical debt?" I actually think there is a good answer to this question, and I strongly suspect someone here can explain it (and how SmartBCH is superior):

https://np.reddit.com/r/ethfinance/comments/sbppnq/what_technical_debt_all_credit_to/

I have been responsible for maintaining about 20+ microservices, split based on their business logic domains, with a team of <5 developers for the past few years, and up until mid 2021, we hadn't had many issues keeping up with adding additional features, fixing bugs, and updating infrastructure.

However, last year, we started struggling to stay ahead of technical debt incurred by security remediation when our company fully implemented JFrog Artifactory as a replacement to Nexus (artifacts were rarely being blocked in Nexus). Our implementation of Artifactory blocks all artifacts with a medium severity or higher, which initially introduced a rather large remediation effort to be able to use it as our artifact repository, and since we have migrated, it has been common to suddenly see blocked versions of major frameworks such as Spring Boot, Spring Data, various NPM packages, etc..

Unfortunately, while our microservices aren't tightly coupled to each other, they do rely on many of the same major frameworks, so if a dependency gets blocked and requires a security update to a new major version to be compliant, we have to make similar changes across most, if not all of our microservices. Depending on the changes required to migrate to the new version, this effort could be minimal or MASSIVE. Deferral of the upgrade is possible, but limited to 30 days.

The additional technical debt from security remediation has me considering merging some of our microservices together, or potentially removing some common functionality, like database queries and similar work, out into separate microservices to reduce the number of microservices that are touched when an upgrade is needed. Currently, we are down to 2 developers and myself on the team, and it has become a challenge to get anything done outside of security remediation due to the duplicated efforts and testing required for the more impactful remediation.

Are there other teams out there facing the similar issues? If so, how did you manage to mitigate it?

TL;DR: Small team of developers having trouble managing technical debt on 20+ microservices that share frameworks/dependencies and would like to know if anyone else has faced similar struggles, and what solutions were employed to help mitigate the duplicated effort and complexity.

You often see those developer who cannot be fired because the software is so badly written but only them understand how it's written. There is no documentation, the code is tangled, methods names make no sense, re-factoring would take years, and newcomers are just unable to really be productive without the help of those "monopoly" developers.

In software, we have the notion of "technical debt" which is when you generate bad infrastructure because you build something quickly and thoughtlessly, and then it slows you down in the future because you either need to work around it or replace it. Sort of like if you assemble a rickety bridge during an invasion in the war, but you need to keep a bunch of troops behind to maintain it instead of building a solid bridge and freeing up the troops to advance.

Most previous innovation depended on the idea that the air, water, land and our lungs are suitable dumping grounds for dangerous chemicals: directly dangerous like nitrogen oxides and indirectly like carbon dioxide.

This became unsustainable, which is leading us to have to go back and "fix the mess" before we can move forward again at full speed. An enormous amount of innovative capital is tied up in fixing the mess and it doesn't directly make our lives dramatically better. I love my EV, but when you consider the enormous technological overhaul it took to get from a combustion engine to a battery-powered motor, it's hardly as much of a leap forward as you might hope. Except...it isn't killing me, my family, my neighbors and the planet.

This raises the question: outside of fossil fuel infrastructure (which continues to be built!) what other forms of technical debt are we accruing right now?

I admit I haven't really surveyed the literature to see if this is a common take: it's essentially just a shower thought.

Hi, I am working as a contractor for bunch of clients. One of them have an issue with people leaving company, tired of working on legacy systems, being on-call, spending 70% of time fixing ad-hoc issues. I was wondering how would such company try to survive. It gets difficult to hire new people (especially that these jobs require certain skillset), old people are walking away (with the knowledge they had). Have you experienced / are you experiencing similar thing? What steps does the companies take to restructure and get back on the track? I'd like to help the managers as I really believe in their product.

Hey guys and gals

I could use a little bit of perspective on my situation.

We are a B2B SaaS company and are riddled with technical debt. As I know other companies are to some extend. We have been around for many years but we haven't moved very much.

The next project is a redesign and a 1:1 rebuild of our architecture on our primary components. It's going to take at least a year according to some. Two according to others. To make matters worse, this has been promised to customers for several years. It's a real shitshow, but that is what I'm here to do something about.

I had a talk with our principal architect today, who basically built most of the old platform. He was very adamant that we wouldn't be able to do anything else because we are locked in the old architecture and are low on engineers. He firmly believes we can't build anything new and innovative because his team would have to support old and new. It also seems like he's opposing doing anything that removes features from current customers for some reason.

I respect his knowledge on the architecture but I naturally don't share the strategy here. Unfortunately I believe others buy into this narrative as well and if this is in fact how it's going to go the next couple if years, I can't see what we would use Product Managers and Product Designers for. All this requires is a delivery team that chops away on the backlog. Not exactly the recipe for great products.

I have other initiatives and priorities I want to talk about and I fully understand the constraints we are working under. I believe I have my research in order but I fear that everything is going to be shot down, because everything is about getting rid of technical debt. I just don't see us survive this narrative. Solving zero problems for two years sounds like suicide. I really want to work through this because I believe Product Management can play a major role in the turnover of this company. My VP Product is on the same page. We really want to change this position.

So what can I do? Do I just keep showing stakeholders my research and make my arguments? Is he right? Can this strategy really be the best solution to our problems? The customers and markets are moving and we are stuck here with rebuilding the same platform almost 1:1.

Thanks in advance :)

I recently came across the phrease "technical debt" in reference to software engineering.

I really liked it and think it would apply to plant engineering too - if we don't have the right design standards, commissioning standards, and maintenance standards then we see a buildup of "technical debt" where we have to revise designs, change commissioning parameters or put more time and effort into maintenance than we need to.

Just wondering if anybody has any references to this phrase being used in electrical/mechanical engineering before?

Despite over ten years experience, I still can't get over one thing: technical debt. Every company seems to have it, and yet I've always found it tedious and frustrating to work with or around. Others seem to have learned to more or less live with it. Some teams have more, some less.

Lately, I've been finding myself staring at that hard granite face of Tech Debt Mountain. Every morning I take my pickaxe and start chiseling a little off. The next morning, the mountain hasn't moved; despite the grueling work, the difference is hardly noticeable. I long for the green field in the valley below.

This is what my work has been feeling like lately especially. We have tech debt and lots of it. We have high unit test coverage, CI pipelines, code review, and still heaps of tech debt. We also have a sprawl of complexity as systems have been built over the years and developers have come and gone. We have an architecture that forces even many simple changes to wind their way across "the Layers," which cross system boundaries. We have a plan to improve the architecture—incrementally because that's the only thing the Business will tolerate—and yet it is slow going, interwoven with competing business priorities ("revenue generating") and any other urgent matter.

I've been here a few years now, and some of the same architectural grooves I noticed at the beginning are still there—to be smoothed over someday, eventually, maybe. If I had to diagnose our particular causes, I'd say years of neglect followed by an almost manic pace of new feature delivery, many hands touching the code over time, and little "adult supervision" over the system design choices entry-level developers are making (again, to keep high work in progress in the belief this will lead to more features faster). I've slowly gotten them to start thinking more about design before coding, but that continues to be a work in progress.

The reasons why technical debt exists may be different elsewhere; regardless, most places seem to have it, and it gives the feeling so much more could be done with the work day if tech debt weren't continuously pulling developers back down.

I'm thinking of quitting just because I am so tired of spending eight hours a day plowing head first into this stuff over and over again (among other things). Maybe a change means dealing with technical debt, but at least it will be in a new and different form; maybe the team will be bigger and better equipped to deal with tech debt. Maybe I'll

Have you ever heard of a situation like this? A owe a debt of​ gratitude​ to​ B B use A's debt​ of​ gratitude​ as​ an​ excuse​ to​ take advantage from A

Is there more bad/overly complex architecture in BI/data now that "Cloud"/SaaS makes it dirt cheap to scale if more CPU/RAM resources are needed? I.e. It's easier to hide Technical Debt with it?

If the dashboards and ETL are processes are suffering the low hanging fruit solution is to simply get bigger machines. It's the easy solution.

"Ain't nobody got time to write good code, architect models to deliver optimal performance." mentality seeping in.

I have noticed this with some of the companies I work with, the data models are unnecessarily complex due to a combination of time pressure, staff that don't have a lot of experience but build anyway, and barely any check on the work they are delivering.

Bad performance? Simply blame the infrastructure and get bigger machines. It's the "easy" solution.

... I wonder what will happen a decade down the line.

Hi,
I compiled a simple list to check if a software project is doomed to drawn in technical debt.

Context: Most of our clients have an industrial background and many think they can by custom tailered software like some industrial tool.

I like to give them a simple checklist and with a methapher they can grasp (e.g. steal quality).

Here is the list:

• Do you write unit tests?
• Are there automated end-to-end and integration tests?
• Are you allowed to plan efforts for refactoring and enablers?
• Do you take actions to make occurring mistakes impossible in the future? (e.g.: by creating automated tests, making the UI more intuitive, …)
• Do the developers know about Clean Code (e.g.: SOLID principles)?
• Are there opportunities to learn together and exchange knowledge? (e.g.: CoPs, pair work, …)

Did I miss something? What are your thoughts?

I’ve dealt with my fair share of spaghetti. But unless there was an appreciable metric to point to I’ve never felt the need to go in and fix something because it felt wrong.

What am I missing? Does the job is does the job, right?

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade; we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen firsthand how this impacts engineer productivity and morale, and at the end of the day product delivery.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

https://preview.redd.it/v0mzvqb5lod81.png?width=2322&format=png&auto=webp&s=df92856022826c1ebb87098b7e047c3638f1872e

Hello,

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade; we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen firsthand how this impacts engineer productivity and morale, and at the end of the day product delivery.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

Caribou in action!

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade; we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen firsthand how this impacts engineer productivity and morale, and at the end of the day product delivery.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

https://preview.redd.it/5u2t004svwd81.png?width=2322&format=png&auto=webp&s=d194df57ed171e38a27e6feabe489d515b2b1249

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade; we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen first-hand how this impacts engineer productivity and morale, and at the end of the day product delivery.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade; we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen firsthand how this impacts engineer productivity and morale, and at the end of the day product delivery.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

Hello,

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade; we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen firsthand how this impacts engineer productivity and morale, and at the end of the day product delivery.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

Caribou in action!

Hello,

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade; we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen first-hand how this impacts engineer productivity and morale, and at the end of the day product delivery.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

Hello!

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade and we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen firsthand how this impacts the business agility and its ability to compete; not to mention engineer productivity and morale.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

https://preview.redd.it/5xtiw8bvfod81.png?width=2322&format=png&auto=webp&s=8547fb04bf02f2cdd2c2184386412eef47219165

Hello!

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade and we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen firsthand how this impacts the business agility and its ability to compete; not to mention engineer productivity and morale.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

Hello!

We are happy to announce the launch of Caribou, a tool to help engineering teams manage the technical debt in their projects! The product is currently in beta, available for free and we’re looking for feedback! You can find it at https://www.hellocaribou.com/

We have been software engineers for about a decade and we know how important it is to keep codebases in good shape and to pay back technical debt. We’ve seen firsthand how this impacts the business agility and its ability to compete; not to mention engineer productivity and morale.

Despite the importance of technical quality, it is not always easy to prioritize technical projects and find large chunks of time dedicated to paying back technical debt. The only way we’ve been able to keep our codebases in good shape was to do improvements continuously while working on features.

This approach worked very well for us. As we started doing it with a larger team, we realized we needed a better way to manage these technical improvements. Specifically, we needed a way to understand what are the improvements being done across the codebase, what is their status, and who are the engineers doing the improvements. This would help us ensure we are prioritizing the right improvements and also that we are recognizing the engineers for their work. This is extremely important to build a culture of technical excellence in the team.

This is why we’ve built Caribou. We hope that we can help other engineering teams around the world improve their codebases continuously, recognize engineers who contribute to this and create a culture where code quality is valued.

So how does it work? In simple terms, Caribou, once configured, monitors all the changes in your repository and displays a dashboard with the progress of specific migrations along with who is contributing to these migrations. Caribou allows you to define all sorts of migrations using an easy-to-use rules engine; for example, changing the project architecture, replacing a library, or changing some coding conventions. You can get inspired by our examples in the docs section.

Please give it a try at www.hellocaribou.com and let us know what you think!

https://preview.redd.it/tnpnml85cod81.png?width=2322&format=png&auto=webp&s=c14b7ec709e7e6ac52b84055f3a41c28091d7768