Transactional Billing System: Under 30-Day Financial App Development

In April 2024, we participated in a contract bid to develop a transactional billing system for a law firm. The project had a three-month deadline, already compressed due to delays in data warehouse integration. Though we weren't initially selected, by May 2024, the client returned with an urgent request - their chosen agency had made minimal progress, and they needed delivery within a month.

The inherited codebase had significant challenges:

• Invalid assumptions were made about events' data structures
• Full table scans were required for each operation
• Implementation was a loosely connected collection of Python scripts

Given our timeline, we decided on dumping the code and building a new system. Our solution included:

• Celery canvas-based infrastructure for incremental data ingestion
• React frontend for invoice management and transaction verification
• Django backend API for system operations

Throughout development, we maintained continuous communication with the client to ensure the shortest possible feedback loops. We implemented an incremental delivery approach, enabling the client to begin testing features as soon as they were ready. This proved crucial in meeting the aggressive timeline.

The project went live within our 30-day target. While we encountered some post-deployment issues, all were resolved within a week. The client achieved their business objectives, and we demonstrated our ability to deliver under pressure without compromising on quality.

This rapid delivery succeeded through pragmatic technical decisions, clear communication channels, and focused incremental development. The client achieved their objectives, and we demonstrated our ability to deliver quality work under pressure.

Legacy Ticketing System Rescue: Clearing Backlog, Performance, and Security Issues

In June 2024, a former client approached us with an urgent problem. Their event ticketing system, previously maintained by an external vendor, had deteriorated significantly after being brought in-house. The system faced frequent outages during peak ticket-sale periods and had accumulated a substantial bug backlog. With a deadline of roughly six months to turn the situation around, we accepted the challenge.

However, the initial codebase assessment revealed technical debt far worse than anticipated:

• Running on unsupported Django 2.1 with outdated dependencies
• Inconsistent, duplicated code implementations where similar features were coded differently without purpose
• Minimal test coverage, with only 50% of existing tests passing
• A perplexing infrastructure setup with three redundant Nginx instances, suggesting fundamental misunderstandings of containerization and Kubernetes principles

Our six-month rescue effort focused on three key areas:

1. Modernization: We upgraded all dependencies to supported versions, replacing or removing unnecessary ones. Some dependencies were so superfluous that their original purpose remained unclear. Others required complete in-house rewrites.
2. Code Quality: We unified components to resolve permission-related bugs and implemented comprehensive testing for critical paths. Many bugs stemmed from inconsistent behavior across different user permission levels.
3. Infrastructure: We streamlined the deployment architecture, eliminating redundant services and optimizing for high-traffic periods.

By the year-end deadline, we had achieved all objectives: clearing the entire bug backlog, achieving zero downtime during peak traffic periods, and dramatically improving the system's maintainability.