The concept combining/merging two or more TLFs into a single TLF wherever possible. Lean TLF shells are programmer-centric and ensure no violation of any regulatory and submission compliances. The primary focus of Lean TLFs is to improve programmers’ efficiency by reducing the time of TLF generation at all levels that involve original, validation and review. At the same time, Lean TLFs reduce/eliminate the programming errors, thereby improving the productiveness of the programmers and eventually paving the way for higher productivity of the programming team.
In clinical trials, multiple TLF's programmed by the programming team may not end up in CSR, and usually, TLF's undergo changes based on the lapses in mock and SAP amendments.
There's a bottleneck caused by the programming team because of the dynamic nature of these modifications and updates. Also, due to the short turnaround time, there's a high probability of programming errors that might lead to rework and affect the delivery timelines and the quality.
The purpose of this blog is to offer a conceptual framework or approach for ‘Lean TLF Mock Shells' that mitigate the defined problems and thereby eliminate the programming team as a bottleneck while increasing productivity, and therefore Lean TLF is a programmer's boon.
Conceptual Framework Approach
Building a Lean TLF Mock is both a top-down and down-top approach. It is a journey that is not limited only to one clinical study, but over a period, will get imbibed into the programming process and help programmers with advanced methods. It will offer a competitive advantage to the CRO over its competitors. A conceptual framework is an approach that is visualized and can be evolved by following the below process:
- Development of Lean TLF should be a collective process involving all the functional members starting from TLF development to CSR finalization. The programmer should be active at all stages of this process.
- TLF mock development should be cross-functional as it involves the various functional departments like statisticians, medical writers, managers, team leads and programmers. The mock shells drafted should be open for changes at any point in time if a better mock layout or format is found in due course of time while implementing or programming.
- Communication channels to implement identified changes should be quick and easy to avoid miscommunication/confusion among programmers. The framework suggests a senior programmer under the supervision of a statistician should take up this responsibility because these changes are usually identified at the programming level by the programmers.
- Since TLF mock development is essential in the evolution of Lean TLF, programmers play a vital role in mock development. Most of the time, the programmer who is also the final stakeholder involved in programming and generating the TLF output is not part of this process. Thus, leaving a gap between TLF mock developer and the programmer. So, this framework suggests involving programmers in mock development either directly or indirectly.
- The direct approach involves the programmer either in development or review of the mock. However, the indirect method involves the programmer offering inputs on the challenges/difficulties faced during the generation and implementation of a specific TLF or during brainstorming, discussions, suggesting better layouts of the TLF’s.
- CSR visualization should be made available to TLF mock development team that will help to identify the necessary TLFs which end up in CSR and avoid unnecessary TLF programming.
- The cross-functional team involved in mock development should review previous TLF studies and develop the best layout for the mock.
- The mock development team should identify repetitive information in TLFs and eliminate such information by combining such TLFs or keeping repetitive information in one specific TLF only.
- Remove TLF's with less information and move them to the appropriate and relevant TLF considered the most suitable.
- While programming, the programmers should be encouraged to be more creative while modifying the TLF layout/format. E.g., changing columns to rows or vice versa may enhance aesthetics by reducing the programming burden and time.
- The framework suggests the 80:20 rule. Here 80% of TLF mock shells should be standardized and used as routine TLF’s such as demographic and baseline characteristics tables, AE tables, summary tables, shift tables, basic Listings, basic figures like line plots, box plots, and more. The remaining 20% of TLF’s can be partially standardized and made flexible for easy changing of layout as per specific study requirements. E.g., when you are considering the efficacy analysis of a new questionnaire, you can use the older questionnaire TLF templates for reference and use the template that is much closer and requires minimum updates.
- If the earlier templates are not suitable, the TLF development team should consider creating a new TLF mock shell that is highly efficient and effective for the programmer to develop.
Lean TLF vs Traditional TLF
- Lean TLF’s are efficient from the programming point of view.
- Lean TLF’s are effective as they provide all the necessary information and eliminate repetitive information.
- Lean TLF’s are productive because it is cost-effective.
- Lean TLF's are helpful as they help enhance the programmer’s creativity and thought process by allowing them to probe data, documents, and get into Mock TLF development and eventually end up with Lean TLF layout. However, in the traditional method, programmers follow Mock TLF methods and programme outputs that are erroneous as there's no clarity on data and for generating non-specific TLFs.
- Lean TLFs reduce repetitive work substantially because of fewer or no programming errors.
- Lean TLF reduces the reviewers time considerably because of fewer outputs and concise information.
- CROs that have implemented the Lean TLFs concept for a couple of years are reaping the benefits of having a highly skilled programming team with thorough knowledge of the TLF generation process. From TLF mock development to CSR finalization, CROs will have a significant competitive advantage, and their programming teams will be their USP.
- Implementing the Lean TLF concept creates a lean programming culture that will help train the new programmers without too much effort. The implementation will help enhance their productivity, and usually, it will be much higher when compared to the traditional TLF approach.
Lean TLF Mock Shells is a unique concept. By implementing this concept, CROs have observed enhanced productivity of the programming team with efficient and effective programmers. In the context of the Lean TLF concept, an efficient programmer is a programmer who generates a TLF output way faster than the traditional programmer, and an effective programmer is a programmer who develops the TLF correctly despite mistakes in the TLF with zero programming errors. Lean programmers are the need of the hour, and this concept will help provide efficient and effective programmers who offer a competitive advantage in the CRO industry. Talk to the experts at ACL Digital for more information.