The Resource Generator is a Django-based utility designed to make software demonstrations faster to prepare, easier to repeat, and more credible for operational audiences.
In transport management software, the quality of a demo depends on more than the screens being shown. A convincing demonstration needs realistic supporting data. Drivers, vehicles, trailers, depots, locations and contact details all need to feel plausible enough for a planner, operator, administrator or customer to recognise the scenario as something that could exist in a real transport operation.
Creating that data manually is slow, repetitive and prone to inconsistency. It is easy for demo environments to end up with incomplete records, unrealistic names, invalid locations, missing contact details or data that does not join together properly across the workflow.
The Resource Generator was built to remove that friction.
It provides a structured way to generate realistic, demo-safe resource data so that product demonstrations can focus on the value of the software rather than the manual effort required to prepare the environment.
Why I Built It
Product demonstrations often rely on a large amount of hidden preparation work.
Before a feature can be shown properly, the supporting data needs to be in place. For transport software, this can include:
- Drivers
- Tractor units
- Trailers
- Locations
- Contact details
- Depot or operational reference data
- Resource records used in planning and allocation scenarios
This information does not need to represent a real customer, but it does need to be coherent. A demo planning workflow is much stronger when the drivers, vehicles and locations look operationally plausible. Poor demo data weakens the story, distracts the audience and can make good software look unfinished.
The Resource Generator was created to make that preparation work faster, safer and more repeatable.
Instead of rebuilding resource data manually for each demonstration, the tool provides a consistent starting point that can be adapted to the scenario being shown.
The Problem It Solves
Poor demo data creates several avoidable problems.
It can make the product feel artificial. It can cause screens to look empty or unfinished. It can break the flow of a demonstration when records do not connect properly. It can also shift the conversation away from product value and towards explaining why the data does not look right.
That matters because a product demo is not simply a tour of screens. It is a narrative. The data needs to support that narrative.
If the demo is about vehicle allocation, the vehicles and drivers need to make sense. If the demo is about depot planning, the resources need to look like they belong to a real depot. If the demo is about operational visibility, the locations need to map correctly and behave as expected.
The Resource Generator helps solve this by creating structured, realistic and reviewable demo data that supports the product story.
What It Generates
The tool creates realistic demo resource data, including:
- Driver names
- Tractor registration numbers
- Trailer records
- Demo-safe phone numbers
- Location records
- Latitude and longitude values derived from postcodes
- Resource records suitable for transport software demo scenarios
The generated phone numbers use reserved fictional number ranges commonly used for television, film and other non-real examples. This allows the data to look credible without accidentally exposing or using real personal phone numbers.
The location data is also designed to support realistic demonstrations. Latitude and longitude values are derived from postcodes so that maps, planning views and location-based workflows display correctly.
This is important because demo data needs to look authentic, but it should never rely on live customer, employee or personal information.
Key Benefits
The Resource Generator provides several practical benefits.
Faster demo preparation
The tool reduces the amount of manual spreadsheet work needed before a demonstration. Instead of creating drivers, vehicles, trailers and locations by hand, the user can generate a coherent resource set more quickly.
This makes it easier to prepare demos at short notice and reduces the overhead involved in setting up demonstration environments.
More consistent demonstrations
Manually created demo data can vary significantly between examples. Records may be named differently, structured differently or contain missing fields.
The Resource Generator improves consistency by applying a repeatable approach to creating resource data. This helps ensure that demonstrations are easier to prepare, easier to maintain and easier to reuse.
More credible product walkthroughs
Realistic data helps audiences understand the product more quickly.
When a planner or operator sees familiar-looking resource data, they can focus on the workflow and the value of the software rather than questioning whether the example is realistic.
This improves the quality of product conversations because the demonstration feels closer to a real operational scenario.
Lower privacy and commercial risk
Using real customer, employee or operational data in demos creates unnecessary risk.
The Resource Generator supports realistic but fictional data, helping avoid exposure of sensitive information while still keeping the demo credible.
This balance is important. Obviously fake data can weaken a demonstration, but real data can introduce privacy, confidentiality and commercial sensitivity concerns.
Better storytelling
Good demos depend on good stories.
The Resource Generator supports better storytelling by ensuring the supporting data fits the scenario being shown. It helps create an environment where the product narrative is clearer, the workflow is easier to follow and the benefits of the software are easier to explain.
Less repeated manual effort
Demo preparation often involves repeated low-value setup work.
The Resource Generator reduces that repeated effort by standardising part of the preparation process. This allows more time to be spent on the quality of the demonstration, the customer conversation and the product value being explained.
Project Purpose
The purpose of the project is simple:
To make realistic software demo resources easier, faster and safer to create.
The Resource Generator is not intended to be a production implementation tool. It is not a replacement for customer onboarding, live configuration or formal master data management.
It is a focused product utility designed to support better demonstrations by improving the quality and consistency of the data used in demo environments.
Its value comes from solving a practical problem: demo preparation takes time, and poor data can undermine otherwise strong product demonstrations.
Technology Stack
The project is built using:
| Area | Technology |
|---|---|
| Backend | Django |
| Front end | Bootstrap |
| Data processing | Python and Pandas |
| Input method | Structured forms and spreadsheet-driven inputs |
| Output | Reviewable, demo-ready resource data |
Django was chosen because it provides a strong foundation for building a practical data-driven web application quickly. It includes routing, forms, models, validation patterns and admin functionality without requiring unnecessary infrastructure work.
Python was a natural fit because the project involves structured data preparation. Pandas is particularly useful for handling tabular inputs, transforming records and preparing outputs that can be reviewed or reused.
Bootstrap was used for the front end because the interface needs to be clear, functional and quick to extend. The purpose of the tool is not visual complexity. The purpose is to make the workflow simple and efficient.
Why Django Was the Right Choice
This project was also a deliberate development exercise.
Building the Resource Generator in Django gave me a practical way to deepen my experience with a different web framework while solving a real product problem.
Django was useful because it allowed me to:
- Build a working web application quickly
- Focus on the workflow rather than infrastructure
- Use a structured backend without excessive boilerplate
- Create forms and outputs efficiently
- Keep the project maintainable
- Handle data-driven logic in a clear and extensible way
- Build something with practical value rather than a purely theoretical exercise
For a personal product utility, Django provides a good balance of speed, structure and maintainability.
Process Overview
flowchart LR
A[Demo Scenario] --> B[Enter or Upload Resource Inputs]
B --> C[Generate Demo Resources]
C --> D[Review Output]
D --> E[Use in Demo Environment]
The process is intentionally straightforward.
The user starts with a demo scenario, enters or uploads the required resource information, generates the data, reviews the output and then uses it to support the demonstration.
The simplicity is deliberate. The tool is designed to reduce friction, not introduce another complex process.
Why Demo Data Matters
Demo data is often underestimated.
A product demonstration is not just a technical walkthrough. It is a way of helping an audience understand how the product fits into their world.
For operational software, that means the supporting data matters. The audience needs to see examples that resemble the kind of work they actually do. If the data looks artificial, incomplete or disconnected, the demo loses credibility.
Good demo data helps the audience understand:
- What problem the software solves
- How the workflow fits together
- Why the feature matters
- How the product could work in a real operation
- What value the user would get from the process
- How different parts of the system connect
The Resource Generator exists to support that outcome.
It helps turn demo preparation from a manual, inconsistent task into a more structured and repeatable process.
Realistic but Safe Data
A key design principle behind the Resource Generator is that demo data should be realistic, but not real.
That distinction matters.
Using real customer or employee data in demonstrations can create privacy, confidentiality and commercial sensitivity risks. However, using obviously fake data can make the demonstration feel weak or disconnected from reality.
The Resource Generator sits between those two extremes.
It creates data that looks operationally credible without relying on sensitive real-world records.
flowchart TD
A[Need Demo Data] --> B[Generate Driver Names]
A --> C[Generate Tractor Units]
A --> D[Generate Trailers]
A --> E[Generate Locations]
B --> F[Credible Demo Resource Set]
C --> F
D --> F
E --> F
F --> G[Use in Product Demonstration]
This makes the tool useful for customer-facing demonstrations, internal walkthroughs, product reviews and training-style scenarios.
Product Thinking
This project came from a practical product management problem.
Preparing demos involves more than presenting a feature. It requires scenario design, data setup, workflow testing and enough operational realism for the audience to trust the example.
The visible part of a demo is the presentation. The invisible part is the preparation.
The Resource Generator was built by looking at that hidden preparation work and asking:
- Which parts of demo setup are repeated?
- Where does manual data creation slow the process down?
- Which records need to be realistic for the demo to work?
- Where does poor data make the product harder to explain?
- What can be standardised safely?
- What should remain flexible?
- How can the process be improved without exposing sensitive system details?
The result is a focused utility that removes friction from a specific workflow.
It does not try to become a full implementation platform. It solves a narrower and more valuable problem: making demo preparation faster, safer and more consistent.
Scope Control
The Resource Generator deliberately avoids becoming too broad.
It does not manage every aspect of a demonstration. It does not replace product knowledge, customer discovery, configuration expertise or good storytelling.
Its role is specific:
Generate useful, realistic supporting resource data so that demos are easier to prepare and easier to repeat.
That boundary is important.
The tool supports the demo process. It does not become the demo process.
This keeps the project focused, maintainable and aligned with its original purpose.
Example Use Case
A product manager needs to demonstrate a planning workflow.
To make the demo credible, they need supporting resources such as drivers, tractor units, trailers, shifts and depot references. Without a tool, this data may be created manually, copied from old examples or built inconsistently across different demonstrations.
With the Resource Generator, the same type of data can be generated more quickly and reviewed before use.
flowchart TD
A[Need to Demonstrate Planning Workflow] --> B[Define Demo Scenario]
B --> C[Generate Resource Data]
C --> D[Review Demo Data]
D --> E[Load Data into Demo Environment]
E --> F[Run Product Demonstration]
The benefit is not only speed.
The wider benefit is that the demonstration becomes easier to prepare, easier to repeat and easier to explain.
Commercial Sensitivity
This project description intentionally avoids detailed implementation logic, internal data structures and system-specific design rules.
The purpose of the portfolio entry is to explain the product problem, the design reasoning and the benefits of the utility without exposing commercially sensitive information.
The important outcome is clear:
Better demo preparation through faster, safer and more consistent creation of realistic resource data.
Trade-offs
Practicality over complexity
The project favours a simple Django, Python and Bootstrap approach rather than a complex architecture.
That keeps the tool understandable, maintainable and appropriate for its purpose.
For a focused personal utility, simplicity is a strength.
Realistic, not real
The generated data is intended to be realistic enough for demonstration purposes, but it is not intended to represent real customer data.
This reduces privacy and confidentiality risk while still supporting credible product demonstrations.
Repeatable, but flexible
Different demos need different narratives.
A rigid data generator would be less useful because product demonstrations often need to be adapted for different audiences, workflows and product conversations.
The Resource Generator therefore supports repeatability while still allowing the demo scenario to shape the final data.
Current Status
The current version is a working personal utility focused on supporting software demo preparation.
It provides a structured way to create realistic resource data and reduce the manual effort required before a demo.
The interface is intentionally simple. Bootstrap provides a clear and usable front end without unnecessary design overhead, while Django provides the backend structure needed to support the workflow.
Future Improvements
Future improvements could include automatically generating orders or broader scenario data.
However, the project is intentionally scoped around the current problem: generating realistic resource data for demos.
Additional functionality should only be added where it supports that purpose without making the tool unnecessarily complex.
Outcome
The Resource Generator demonstrates a practical product management principle:
Good software demonstrations depend on good preparation.
The project reduces the time and effort needed to prepare realistic demo data. It helps make product walkthroughs more consistent, more credible and easier to repeat.
It also demonstrates an important product skill: identifying a repeated operational pain point and building a focused tool to remove friction.
The value is not in exposing complex technical detail. The value is in recognising that demo preparation is a real workflow, and that improving that workflow can improve the quality of product conversations.
Summary
The Resource Generator is a personal Django, Python and Bootstrap project designed to make software demo preparation easier.
It helps create realistic, demo-safe resource data for transport software demonstrations, including driver names, tractor registrations, trailers, locations and fictional phone numbers.
The project is intentionally focused, commercially safe and practical. It does not expose sensitive design details or attempt to become a full implementation platform.
Its purpose is simple:
Make better demos easier to prepare.
By improving the speed, consistency and credibility of demo data creation, the Resource Generator supports better product storytelling, stronger customer conversations and more reliable demonstration environments.