In about 4 weeks, the first product from MONI’s Oct. 2024 acquisition of PulseWire is planned to launch. We are working hard to meet the deadline.
MyPressAlert.com will do what the website discusses. We won’t go into detail about the feature set, the beta program, our marketing plans or any other deep product details for obvious reasons: it would simply be irresponsible to discuss all of that prior to a launch and inform our competitors about what’s coming.
What we can touch on, however, are some important themes we’ve kept in mind as we built this product.
Scalability – from local to global, MyPressAlert will be capable of capturing information at scale. We think of scale in terms of being able to serve a large, global audience, and also in terms of where we access data and information.
Reliability – a distributed approach to powering the system enables us to quickly sidestep problems, keeping things live and ensuring customers get the access they desire. Writing our own code ensures we can have a product that can do what we want and need, free from any 3rd party requirements.
Trust – very specifically, this is trust in our code. While a single number cannot encompass the whole product, what it can give you is a clue to where time is going. 10,000+. That represents the total number of hand-written lines of code, to this point, which makes up the actual product.
If you’re not familiar with how coding works, here are the broad strokes so you get a picture of where time gets invested.
Key Factors Affecting Time
- Code Complexity: Algorithms, integrations, and functionality impact development time.
- Project Requirements: Clear, well-defined requirements speed up work; ambiguity slows it down.
- Tooling and Frameworks: Using robust tools for validation, testing, and deployment reduces overhead.
- Solo vs. Team: A single programmer has limits; larger projects benefit from collaboration.
- Technical Debt: Writing “clean code” upfront reduces future delays.
1. Writing the Code
A talented programmer can typically write 50-100 lines of functional code per day. This figure accounts for clean, maintainable, and error-free code rather than raw typing speed.
- For 15,000 lines of code, as an example:
- Optimistic estimate: 150 days (100 LOC/day)
- Realistic estimate: 200-300 days (50-75 LOC/day)
2. Validation and Testing
Testing and debugging can take 30-50% of the total development time depending on complexity, testing rigor, and bugs encountered. This phase includes:
- Unit testing
- Integration testing
- System testing
- Validation against requirements
If the writing phase takes 200 days, testing could take an additional 60-100 days.
3. Deployment and Refinement
Deploying the code to production and addressing any post-deployment issues typically adds 10-20% of total time. This phase includes:
- Environment setup (e.g., servers, CI/CD pipelines)
- Debugging deployment errors
- Monitoring performance and stability
Estimated time: 20-40 days.
Total Time Estimate
Adding these phases together:
- Best-case scenario (highly experienced programmer, simple project): 6-8 months (180-240 days)
- Realistic scenario (moderate complexity, robust testing): 9-12 months (270-360 days)
- Worst-case scenario (high complexity, frequent revisions): 12-18 months (360-540 days)
As we look forward to the coming launch of our cross-media insights and data product, we are excited. We believe this product will be revolutionary for many users, enabling real-time data and insights like no other source.
Our post-launch plans are clear internally, and they include the usual focus on fixing anything that breaks under load, refining features and processes based on the user data we’ll be watching (essentially looking for patterns to help us make things smoother, easier and more intuitive to use) and rapid development of the next features to release, adding to the platform’s utility.
We can’t wait to share this new product with everyone next month!
Duane Forrester
SVP, Product
