Software Development Use Cases
Subscribe to this collection and be first to get notified when new content arrives.
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Subscribe to this collection and be first to get notified when new content arrives.
Unlock the secrets to successful software development with this carefully curated selection of real-world use cases.
ARTICLES IN THIS COLLECTION
In this handbook, you’ll find a diverse set of use cases connected to software development.
Learn directly from the hands-on challenges others faced, understanding the strategies that led to breakthrough solutions. By analyzing these scenarios, you'll arm yourself with a toolkit of problem-solving approaches.
Pick a use case from the list on the right or scroll down to learn some details first.
This use case discusses strategies for maintaining project momentum and delivery in environments characterized by frequent shifts and changes in team dynamics. It provides insight into how the Kanban system facilitates agility and adaptability in project management.
The problem tackled is the inefficiency and resource waste that occur when teams face frequent pivots and alterations in team composition without a clear process to manage these changes.
The implementation of a Kanban framework, specifically the upstream-downstream approach, helps to manage tasks effectively.
The use case delves into how the CASL library can enhance permission management in web applications, addressing the common challenges associated with complex access control requirements.
The problem tackled is the difficulty of managing user permissions in multifaceted applications, particularly when dealing with a variety of user roles that require access to certain data, a problem that escalates as the application and roles evolve.
CASL (an acronym for "Create, Read, Update, Delete") is a JavaScript library that allows for defining detailed user permissions aligned with their roles, streamlining the process of who can see and do what within the application.
The use case provides guidance on enhancing team performance through effective use of metrics, warning against the pitfalls of misusing them as targets.
The article confronts the issue that simply setting targets on metrics does not necessarily change behavior, as individuals might manipulate the system to meet these targets without genuine performance improvements.
Like an EKG, metrics should be used to diagnose issues and inform strategies for improvement rather than to set direct targets for teams.
Effective metric usage involves four golden rules: not relying on a single metric, keeping metrics objective, measuring only what's worth measuring, and recognizing that there is no universal set of metrics.
The use case discusses the debate between microservices and monolithic architectures, especially for smaller projects, and provides insights into why sometimes a monolithic structure might be more beneficial.
Choosing between microservices and a monolithic architecture affects development complexity and speed. While microservices are scalable, they introduce complexity and slow initial development, whereas monolithic architecture, although less scalable, can be quicker and simpler for smaller projects.
Adopting a modular monolithic approach can be effective for certain projects. This method allows for easy separation into logical modules and the ability to shift to microservices later if necessary.
This use case presents an Expectation Workshop as an essential tool to address the common issue of delays and frustrations in software projects caused by mismatched expectations among stakeholders and developers.
The use case tackles the challenge of misunderstandings, rework, and missed deadlines in software development, exacerbated by differences in backgrounds and communication styles in multicultural teams.
The solution involves conducting an Expectation Workshop that encompasses 8 key steps. In the example presented by the use case, Expectation Workshop allows the team to capture information asymmetry and validated false beliefs, which led to process improvements, faster delivery of higher quality work, and greater team satisfaction.
This use case demonstrates how Zod, a robust validation library, was pivotal in resolving integration issues stemming from the poorly typed code in the AdminJS library.
The use case focuses on the difficulties encountered with AdminJS's inadequately typed code, which led to integration complexities and the potential for runtime errors.
Zod was leveraged to define precise type schemas and perform data validation against these schemas, which facilitated early error detection during development and bolstered overall code quality.
This use case delves into the strategic migration from Bitrise to GitHub Actions for a more streamlined CI/CD process.
The use case addresses the challenges of scaling up mobile application development processes with Bitrise and the need for a more flexible, cost-effective solution.
The solution involves transitioning to GitHub Actions, which offers greater control over CI/CD pipelines and integrates more seamlessly with GitHub repositories, as detailed in the study.
This use case addresses the complexities and challenges of managing technical debt in a legacy software system that suffers from poor code quality, scalability issues, and insufficient testing and documentation.
The use case presents the challenges that technical debt poses to maintaining and scaling software systems effectively. Additional challenge was the selection of the right approach and debt prioritization.
The solution involves a strategic approach to technical debt, assessing its impact, and integrating its management into the daily workflow. The team used a tech audit to prioritize issues, aligning refactoring with business goals, adopting the Testing Trophy strategy over traditional testing pyramids, and taking incremental steps in refactoring with a focus on business value and strategic improvement
This use case details a method for efficiently extracting information from PDF pitchdecks, tackling the difficulties of handling unstructured data and graphical elements.
The problem was the extraction of pertinent information from a large volume of pitchdecks in PDF format, which are typically unstructured and feature a mix of text, images, and spatial relationships that standard text extraction tools struggle to interpret.
The solution involves using AWS Textract for its OCR and machine learning capabilities to extract text, coupled with OpenAI's GPT-3.5 and GPT-4 models for summarizing and parsing content to extract specific information, such as names or financial data.
This use case discusses the enhancement of software quality through the collaboration of programmers and QA personnel in pair testing.
The piece addresses the inefficiency and lack of communication that can arise when developers and QA testers work in isolation, potentially leading to misunderstandings and a greater number of defects.
The solution advocated is pair testing, a technique where a programmer and a QA team member work together to test software, combining their perspectives to identify and resolve defects early in the development cycle.
This use case compares tRPC and GraphQL, highlighting tRPC as an effective solution for resolving type safety issues in web development.
The problem addressed is the difficulty of achieving type safety in web development, which has been especially problematic with GraphQL, prompting the need for a better solution.
tRPC is introduced as a TypeScript-oriented solution that integrates backend types directly with the web client, automating type generation and reducing manual coding and configuration hassles, thus streamlining the development process.
