How we develop features at TuringTech

At Turing Technologies we encourage and motivate our team members including engineers, designers and software testers to be involved in end-to-end ownership of a feature.

Our team members have the opportunity to work on several projects with end-to-end ownership this means that we encourage our engineers, testers and product managers to interact with our product designers and external stakeholders. This has resulted in faster development times, because in many cases things/components/elements that look "pretty" to a product designer would become a headache for a frontend engineer to develop.

In this post, we hope to take you through the journey, and hopefully put into perspective everything that is required when given end-to-end ownership of a feature release.

Why is this feature being developed?

• Why does the end user require this feature?
• What’s the pain point that we are trying to solve? and is this feature/flow going to help the end user?

As tech-sector workers, we build software to solve a problem, hence a solid understanding is the start of the journey.

This first part of the journey aligns with one of our key values Embrace Change, this means to not get demotivated by an unfamiliar situation or challenge.

Documentation and White-boarding:

We take our time thinking about the user flow, the architecture, and the use cases before going into the code-mode.

We use Miro and Loom extensively to document the data flows and the use cases, and even database models. (Heck one of our hiring requirements is if the person can explain their work in a loom video).

Most people are visual learners and one tool that aids understanding of the high-level view of the system is a Database Modeling tool. We have used various tools over the years including Miro, Adobe XD, LucidChart and even Figma. This allows the team to visualize the data flows and changes that are necessary for the feature to come to fruition.

The following shows the final diagram for the feature with the data model.

The time spent documenting makes the implementation of the system very straightforward, so we push our lead engineers to review and give recommendations on specifications created by our product managers.

This touches on another of our values of Keep it Simple.

Keep Stakeholders in the Loop

While developing the feature, our team held two weekly syncs with all the stakeholders. One with external stakeholders in the US, and the other within our local stakeholders (Designers, Developers, Product Managers and Software Testers).

One with the external stakeholders to resolve any general questions about the project and discuss blockers, if any another, a technical sync between engineers and designers for in-depth technical discussions.

It’s very important to utilize these meetings and be aware of any major blockers. We always find that people are more understanding when you are clear with them and raise issues earlier in the project. Every project has obstacles along the way, what’s important is how you manage expectations and are clear with your progress.

‍

It's all about the Team

During the implementation of the feature, there are many people that are part of the effort that must be kept in close contact.

For example:

• UX Designers ensure that whatever is being built makes sense from the end-user perspective. (Keep it Simple)
• Web Engineers provide the models, and end result.
• Product Managers translate the requirements of the end-users into the technical realm for the engineers to implement.

Let's do some testing!!!

As the release date approaches, we allocate a specific day to test the feature end-to-end. Engineers, product managers and other stakeholders test through various use cases in the staging or pre-production environments and collect any bugs or improvements that can be added.

It helps the team align on their expectations vs. reality and ensure that we built what we were supposed to be building.

Takeaways

In conclusion, there are several takeaways from this experience:

• Face-to-face interaction and whiteboard the system to understand the data-flows help immensely to unlock the rest of the project. (That's why we're a hybrid workplace)‍
• Feature Flags are very IMPORTANT: Adding a feature flag allows software developers to roll out the feature with confidence, and provides a mechanism to turn off the feature is there are any issues.
• The power of the team: Pairing designers, engineers and product managers can speed up the process of implementation, and teach you some valuable lessons about how others think and tackle problems together.
• The work is not over once a feature is released: It’s important to have monitoring and analysis of the feature components to understand the performance and business impact (we use tools like Sentry, and MixPanel). A feature that’s unusable because it’s slow doesn’t provide any value.

Want to know which tech stack we use to implement state-of-the-art features at TuringTech? Checkout our expertise.