A White paper by Shellcraft Studios about a project made by Shellcraft Studios.
Parking in urban areas has long been a challenge for both drivers and city planners. In crowded cities, parking regulations can vary significantly from one block to the next, and even the most experienced drivers can find themselves puzzled by parking signs. The problem becomes even more complex for those with limited visibility or those who aren't familiar with the specific regulations of the area.
For example, in many parts of Sydney, parking signs are often placed high up on poles, making it difficult for some drivers to read the text or understand the restrictions. Furthermore, the language used on parking signs can be confusing, especially when multiple signs are grouped together, each indicating different times and conditions. For someone with a visual impairment or a non-local driver, these signs can be a constant source of frustration. And, as anyone who has received a parking fine knows, the consequences of misunderstanding a parking sign can be severe—financially, emotionally, and practically.
This chapter is all about pinpointing the specific problems ParkEase aims to solve. The goal was never just to make an application for interpreting parking signs; it was about creating a solution that would genuinely improve the parking experience for as many people as possible.
Through conversations with people who experience parking challenges regularly, we began to understand the pain points more clearly. We wanted to identify not just the obvious frustrations but also the less discussed issues that come with parking regulations. Here's a breakdown of the key pain points:
After identifying the problems, the team realized that no single solution on the market addressed all of these pain points at once. Existing solutions were either too simple (relying on manual, static maps and guides) or too complex (overloaded with features that didn't solve the core problem). What was missing was an intuitive, automated solution that could instantly interpret parking signs, make sense of complex regulations, and notify users of the time left on their parking meter—especially when it came to those who couldn't easily read the signs themselves.
ParkEase was born out of the desire to bridge that gap. We knew that a camera-based solution leveraging AI would be the key. By using a smartphone camera to capture images of parking signs, the application could process the data in real-time and provide a clear, understandable interpretation of the parking rules. The system would need to be accurate, simple, and most importantly, accessible to everyone—from people with visual impairments to tourists who speak different languages.
To validate the need for ParkEase, we reached out to various communities: people with disabilities, tourists, local drivers, and even individuals living in areas with high parking fines. Their feedback was invaluable in shaping the application's early development.
A 65-year-old woman with visual impairments explained how she had been fined multiple times because she couldn't read parking signs. Despite her best efforts, it was nearly impossible to understand the regulations without asking others or relying on expensive parking applications that often weren't user-friendly.
A tourist from the UK visiting Sydney shared a frustrating story of parking in a zone that seemed to have conflicting signs. He spent 15 minutes reading the signs, trying to decipher what was allowed and when, and ultimately got fined for misunderstanding the restriction times.
A local driver in Melbourne talked about the stress of constantly worrying about when his parking timer would expire. His day was always interrupted by the fear of getting a parking fine.
These conversations not only highlighted the scale of the problem but also reaffirmed the potential of ParkEase as a solution that could truly make a difference.
In Chapter 1, we established the foundational problem statement: The parking sign system is too complex and inaccessible, and ParkEase could be the answer. This clarity of purpose became the guiding star as we moved into the development phase. We knew that to solve the issue of parking sign confusion, we would need to build an application that was simple to use, accessible for all, and reliable in interpreting a wide variety of parking signs.
The stage was now set to tackle the technical challenges in the next chapters—leveraging the power of AI and combining it with a user-centered design approach. But before that, we had to fully map out the user journey, the technology stack, and the scalability potential, all of which would be discussed in the coming chapters.
With the problem clearly defined, the next step was figuring out how to solve it. We knew that parking sign confusion wasn't just an inconvenience—it was a major barrier for drivers, especially in busy cities where a wrong turn or a misread sign could mean an expensive fine.
ParkEase needed to be more than just an application; it had to be a seamless, user-friendly tool that instantly decoded parking signs accurately and efficiently. But how do you turn an idea into a functional, real-world product? That's what Chapter 2 is all about.
Before jumping into the technical aspects, we needed to map out exactly what ParkEase should do. Based on user feedback, here were the non-negotiables:
Once we had a clear picture of what the application needed to do, the next challenge was figuring out how to build it.
We considered different technologies:
Each of these approaches had advantages and disadvantages, and we had to balance speed, accuracy, and usability when deciding on the final technical stack.
Before any coding started, we needed to visualize the user experience. This meant designing wireframes—a detailed blueprint of what the application would look like.
We broke down the application's user flow into four main steps:
Using Figma™, we started sketching the initial application screens. We wanted a clean, minimalist design so users could get parking information instantly, without distractions.
We kept the accessibility features in mind, ensuring options like text-to-speech, color contrast adjustments, and voice control were part of the early design.
Of course, no product journey is complete without its early mistakes and challenges. Some of our first attempts at designing and implementing ParkEase didn't go as planned. Here are a few of the key failures we encountered:
Failure #1: Overcomplicating the User Interface
What happened:
Our first prototype had too many buttons and options, making the application overwhelming. We originally thought users would want extra features like manual input of sign details, but testers found it unnecessary.
The solution:
We stripped the UI down to just three main screens: camera, results, and timer. Keeping things simple dramatically improved usability.
Failure #2: The AI Misreading Signs
What happened:
The first version of our OCR system had trouble recognizing text on signs with odd lighting or faded paint. It also struggled with signs that had stickers covering parts of the text.
The solution:
We improved our AI training dataset by including real-world images taken under various lighting conditions. We also added error detection so if the application misread something, it would flag it for user confirmation.
Failure #3: Slow Processing Speeds
What happened:
The initial AI model took 5-7 seconds to analyze a sign, which felt way too long. Users wanted instant results, not a loading screen.
The solution:
We optimized our code and switched to a more efficient machine learning model, reducing scan time to under 3 seconds.
After multiple iterations, failures, and refinements, we had a clear roadmap for ParkEase's development. Our plan was now broken down into three main phases:
With a solid plan in place, it was time to start building. The next chapter delves into the technical development of ParkEase—writing the code, training the AI, and assembling the first working prototype.
With the core concept and design finalized, it was time to start the real work—building the first working version of ParkEase. This was the phase where ideas were transformed into actual code, and theoretical solutions were put to the test. The goal was to create a fully functional prototype that could scan parking signs, interpret them, and return clear parking instructions.
But as with any ambitious project, the gap between concept and execution proved to be wider than expected. The initial development phase came with significant challenges, from AI misinterpretations to technical roadblocks in making a web-based timer function properly in the background.
Before writing a single line of code, we had to decide on the technology stack. Since ParkEase was designed to be a progressive web application (PWA) rather than a native mobile application, it required a combination of web technologies and cloud-based AI processing.
| Component | Technology |
|---|---|
| Frontend | HTML, CSS, JavaScript (React.js for UI components) |
| Backend | Google Deepmind Framework (handling API requests) |
| AI Processing | Google DeepMind Vision API + Google Deepmind's latest LLM for interpreting sign text |
| Storage | Cache for temporary image storage before sending to AI processing |
| Background Timer Workaround | BackgroundSiter, a silent MP3 looping system for persistent web timers |
The decision to use Google DeepMind's Vision API was based on its superior image recognition capabilities, which were crucial for accurately reading parking signs. Additionally, Google's LLM provided natural language processing to correctly interpret the sign's meaning.
The first major step was getting the application to properly read and extract text from parking signs. OCR (Optical Character Recognition) was the most logical approach, but early tests quickly revealed its flaws.
At first, we tested Tesseract OCR, a widely used open-source library for text recognition. While it worked well for clean, high-contrast text, it failed in real-world conditions where signs had dirt, glare, or non-standard fonts.
To improve accuracy, we implemented pre-processing techniques:
Despite these improvements, OCR alone wasn't sufficient. The system could extract text, but it had no understanding of what the text meant. This led to the next phase: using AI to interpret the extracted information.
Once we had a way to extract text, the next challenge was teaching an AI model to correctly interpret parking rules.
To train the AI, we needed a large dataset of parking signs from different locations. We gathered:
Each image was labeled with:
Using this labeled data, we trained a custom language model prompt that combined:
The AI went through several iterations before achieving a usable level of accuracy.
Once the AI could correctly interpret parking signs, the next step was integrating it into the user interface.
This process needed to be as fast as possible. Early tests showed delays of 7-8 seconds, which was too long. By optimizing image compression and request handling, we reduced the response time to under 5 seconds.
One of the biggest challenges was ensuring the timer feature worked even when the application was in the background. Unlike native applications, PWAs have strict limitations on background execution, meaning a JavaScript-based timer would pause when the user switched applications.
After testing multiple approaches, we discovered an innovative workaround: playing a silent MP3 file in a loop kept the browser's media session active, preventing the timer from pausing. This allowed us to seamlessly switch to an alarm sound when the timer ended.
This workaround was implemented as BackgroundSiter, an open-source tool designed to keep web timers running on both iOS and Android platforms.
By the end of the initial development phase, we had a working prototype that could:
However, this version still had limitations:
Despite these shortcomings, the first prototype proved that the concept was viable. It was time to refine and optimize before testing with real users.
After months of development, the first prototype of ParkEase was finally ready for real-world testing. On paper, everything worked—signs were scanned, AI interpreted the rules, and the application provided clear parking instructions. But theory and practice are two very different things.
Real-world testing would determine whether ParkEase could handle the unpredictable nature of actual city parking—different lighting conditions, varying sign designs, and user behavior that no amount of coding could fully anticipate.
This phase was crucial because no matter how perfect a product seems in development, real users always interact with technology in ways developers never expect.
Before launching the application to a wider audience, we needed structured testing in a controlled environment.
We chose three distinct test locations with different challenges:
Despite promising results in a development environment, the prototype struggled in real-world conditions. The most significant issues included:
While these failures were anticipated, observing them in action made it clear that the system needed major refinements before it could be trusted in high-pressure parking situations.
The first round of tests provided valuable real-world training data that helped us refine the AI model.
These updates improved AI accuracy from 78% to 89%, a significant step forward but still not perfect.
With AI improvements in place, it was time to release ParkEase to real users.
We launched a closed beta with a select group of users:
Users were asked to use the application naturally and provide feedback on:
Despite our AI improvements, new issues emerged that we hadn't encountered in controlled tests:
These failures demonstrated that regardless of AI sophistication, human behavior remains inherently unpredictable.
After weeks of beta testing and analyzing failures, we implemented the final refinements:
These final adjustments increased AI accuracy to 94% and made the application significantly more reliable and user-friendly.
With ParkEase refined through real-world testing, the next major challenge was introducing it to the public. The technical aspects were robust, but a superior product is inconsequential if people are unaware of it—or worse, don't trust it.
Public adoption wasn't merely about making the application available; it necessitated a clear strategy to engage drivers, city officials, and businesses to take ParkEase seriously.
Although parking confusion represents a universal problem, convincing people to try a new solution proved more difficult than anticipated.
To engage real drivers to use ParkEase, we needed to reach them where they were—both online and offline.
Key Insight: Users who had personally received unfair fines were the most eager to try ParkEase.
Key Insight: A successful launch isn’t just about acquiring users—it’s about iterating rapidly to accommodate their evolving needs.