When car, motorcycle, and e-bike eligibility checks accumulate in one rental endpoint, each new vehicle type can make the service harder to change safely. A practical refactor is to give each vehicle type a strategy, compose its policy from reusable rule objects, and collect failed checks as notifications. That structure is useful when policies genuinely vary or are expected to evolve; for a few stable variants, a straightforward conditional may be simpler.
Why a rental availability endpoint becomes coupled
In André Degaspari’s case study, a rental API began with cars, expanded to motorcycles, and then needed to support electric bikes. The original service handled customer lookup, shared restrictions, vehicle-specific validation, and inventory lookup in one flow. As requirements accumulated, it became harder to see which checks applied to which vehicle, and a change for one type could inadvertently affect another. Degaspari’s case study is a practitioner proposal, not a controlled comparison of refactoring outcomes.
As an Amazon Associate I earn from qualifying purchases.
The design goal is not to eliminate every conditional. It is to make policy differences explicit enough that teams can reason about them, test them, and change one vehicle’s requirements without obscuring the others.
How the strategy, rules, and notifications fit together
Rule objects express individual checks
A rule object represents one eligibility condition, such as minimum age, a required license category, no pending debits, or no active violations. It receives the customer and a notification collector. If the condition fails, it adds an explanation to the collector rather than deciding the whole request by itself.
#1 Best Overall
These are example policy categories, not universal rental requirements. The case study’s sample ages and license categories are illustrative values, not legal guidance or claims about a particular rental company or jurisdiction.
Vehicle strategies select the applicable rules
Each vehicle type gets a strategy that runs the rules relevant to that type. In the case study, the car strategy combines shared financial and violation checks with age and license checks; the e-bike strategy uses a different subset. Reusable rules avoid duplicating the same check, while separate strategies avoid imposing every rule on every vehicle.
A strategy is useful when a family of behaviors can be selected through a shared interface. The Strategy pattern reference describes this as separating interchangeable algorithms so a context can delegate to the selected implementation.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteA registry selects the strategy
A strategy registry maps the requested vehicle type to the corresponding strategy. It also provides a clear place to handle unsupported types. This keeps vehicle selection out of the individual rule implementations and makes the supported set of strategies visible.
The service keeps the request flow
The service can retain a readable high-level sequence:
- Load the customer.
- Select the strategy for the requested vehicle type.
- Run that strategy’s rules.
- If validation permits, query available vehicles.
- Return the availability result and any restriction reasons required by the API contract.
The service coordinates the operation; strategies decide which rules to run; rules evaluate individual conditions; and notifications carry failure explanations. This allocation makes the policy boundaries easier to inspect than a single method that mixes all four jobs.
Notifications can report multiple failures
If each failed rule appends an explanation and evaluation continues, the API can return several reasons a customer is ineligible in one response. That can be more useful to a client than stopping at the first failure, but it is a product and API-contract decision, not an automatic benefit of the pattern. Define whether validation stops at the first failure or collects all failures, and preserve the response shape clients already rely on unless a deliberate API change is planned.
When are separate vehicle strategies worth the added structure?
Use the expected evolution of the policies—not the popularity of a pattern—to decide. The case study acknowledges that its refactored example introduces more classes and concepts and may initially be harder to grasp. Refactoring.Guru makes the trade-off explicit: “If you only have a couple of algorithms and they rarely change, there’s no real reason to overcomplicate the program with new classes and interfaces that come along with the pattern.”
| Approach | Best fit | Main trade-off |
|---|---|---|
| A conditional in the service | A small number of vehicle types with simple, stable differences. | Few abstractions to learn, but the service can become a growing home for unrelated policy branches. |
| Strategies composed from rule objects | Policies differ by vehicle type, change independently, or need focused tests and reuse. | Clearer policy boundaries, at the cost of additional classes, interfaces, and navigation. |
| A rules-engine product | Consider only when the problem needs capabilities beyond ordinary code-based policy composition; assess whether rules must be authored or changed outside the application code. | Potentially more operational and reasoning complexity, especially if execution order or rule interactions are implicit. |
Before extracting abstractions, compare the number and volatility of policy variants, who needs to change them, how visible evaluation order must be, how policies will be tested alone and in combination, and the integration and operational cost. If a conditional remains easy to understand and the policies rarely move, keeping it may be the clearest design.
Do rule objects mean you need a rules engine?
No. A set of ordinary domain-specific rule objects is not automatically a general-purpose rules engine. The former is a code organization choice: the application explicitly calls known checks through a strategy. A production-rules system introduces a different computational model in which conditions trigger actions and rules may interact or chain.
Martin Fowler cautions that “The production rule computational model is best suited for only a subset of computational problems, so rules engines are better embedded into larger systems.” His Rules Engine essay also warns that chaining can make behavior difficult to reason about and debug. It recommends keeping such systems within narrow contexts, limiting or eliminating chaining where practical, and testing carefully because behavior may be implicit. If considering a rules-engine product, Fowler suggests prototyping it alongside a hand-built domain-specific approach.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteHow to refactor without changing rental policy by accident
Start by making current behavior explicit before moving code into new classes. Treat the following as implementation recommendations for applying the design, not as a migration procedure reported as tested in the case study.
Best Value
- 110 Sheets Log Book: This vehicle maintenance log book includes 110 record sheets to track repairs, services, fuel costs, and other vehicle-related expenses. It also comes with 36 convenient “Service Due” stickers to help remind you of upcoming maintenance schedules. Everything you need to keep your car records organized in one place.
- Detailed Information: Each page is carefully structured with dedicated sections for date, mileage, service description, parts replaced, vehicle information, cost, and additional notes. The clear and organized format allows you to maintain accurate records, monitor repair history, and better manage long-term vehicle performance and expenses.
- Enough Writing Space: The record sheets provide ample space for clear and thorough entries. Whether you’re documenting routine oil changes or major repairs, there’s plenty of room to write detailed information without feeling cramped.
- Easy to Use: The spiral binding allows the notebook to lay flat for comfortable writing, making entries quick and convenient. The included 36 “Service Due” stickers can be placed inside the book or on visible surfaces like your windshield or dashboard, helping you keep important maintenance reminders in sight.
- Proper Size: This compact logbook measures 5.5” x 7.1”, which fits easily in your glove compartment, center console, backpack, or desk drawer. Its portable size ensures you can access and update your vehicle records anytime, whether at home, in the garage, or at the service center.
- Inventory the existing checks. Record each condition, the vehicle types it applies to, its evaluation behavior, and the response the client receives when it fails.
- Agree on policy semantics. Decide which checks are shared, which vary by vehicle, whether to stop on the first failure or collect all failures, and how unsupported vehicle types are handled.
- Preserve the API contract. Keep existing response fields and status behavior stable during the structural refactor. Treat any change to eligibility or response semantics as a separate, intentional policy or API change.
- Extract rules and strategies in small steps. Move individual checks into rule objects and group them under the corresponding vehicle strategy. Keep the strategy’s rule set visible so reviewers can verify which checks apply.
- Test policies independently and in combination. Cover each rule’s passing and failing cases, each strategy’s composition, multiple simultaneous failures, and the service’s behavior when a customer is eligible or restricted.
What the case study does—and does not—establish
Degaspari says the real situation involved more rules, microservice integrations, and a broader validation context than the simplified example. The author also reports that two developers implemented a module for their own use cases and that the author reused it elsewhere. These are experience claims, not measured evidence that the approach reduced defects, shortened development time, or improved maintenance.
The case study explicitly says its code examples were AI-generated and that the author did not write the example code. It should therefore be read as an illustrative design proposal, not as code the author personally implemented or verified line by line. The author distinguishes that simplified example from the more complex real-world context.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Recommended Free Tools
