The situation before Agentify
The organization had to keep shipping features on a platform built from legacy layers, fragmented knowledge, and years of accumulated technical debt.
Pending issues cut across the database, business logic, API layer, and WebForms views.
Eighty-five percent of the codebase was still on .NET Framework 4.7.2, with data access relying on 421+ stored procedures.
Unit test coverage was 0%, and there was no original technical documentation to reduce regression risk.
Prioritization involved multiple stakeholders across business and operations, and the context needed to make those decisions was spread across people and tools.
The first 30 days
The first 30 days
We started delivering value during onboarding, not after it.
Business and technical kick-off
We started by understanding product vision, commercial priorities, the current architecture, and the status of migration efforts already in motion.
- Alignment with business stakeholders on priorities and bottlenecks.
- Technical immersion into .NET WebForms, SQL Server, stored procedures, and the Entity Framework migration path.
Environment, repository, and functional context
We set up the local environment, mapped structure and dependencies, and automated the extraction of operating documentation so the team could ramp up faster.
- Full environment setup and structural read of the repository.
- Automated scraping of the support platform and creation of a functional-context skill to speed future AI-assisted cycles.
Stakeholders and critical issues
We ran stakeholder interviews in parallel with backlog work -- delivery started before the picture was complete.
- Interviews with business and operations stakeholders to map real workflows.
- Start of priority issues and a tool evaluation report for support operations.
Intensive delivery + modernization baseline
With enough context in hand, we accelerated on priority issues and closed out a technical diagnostic that would shape the next decisions.
- 3 priority issues merged to production.
- Progress on the SFTP integration, plus an eight-dimension technical scorecard that set the starting baseline.
What we found once inside
Rather than talking about technical debt in the abstract, we measured it: complexity, dependencies, integrations, and maintainability -- scored and documented.
stored procedures referenced
421+
tables mapped
155+
Azure Functions analyzed
51+
maintainability
3.5/10
Findings that shaped the priorities
- 01
The layered architecture showed some consistency, but maintenance risk was critical because there were no tests at all.
- 02
God classes with over 11,000 lines concentrated sensitive business logic in a single file.
- 03
There were legacy and conflicting dependencies, including libraries with no maintenance since 2016.
- 04
The Entity Framework migration had started, but it covered only a small fraction of what needed to move.
- 05
Critical technical knowledge lived in people's heads, chat threads, and scattered tools -- there was no reliable documentation system.
Technical scorecard
Architecture
Security
Scalability
Code quality
Modernization
Dependencies
Maintainability
What we shipped in the first month
What we shipped in the first month
We mixed discovery, delivery, and early modernization work. There was no dead phase where we only studied the system.
01 / 04
Priority backlog unblocked
We fixed issues that touched operational logic and user experience across multiple layers of the product.
- Fix to participant icon display logic.
- Payment blocking for fixed funds across entities.
02 / 04
Incremental data-access modernization
While working through backlog, we also advanced one structural piece of the migration and established a pattern others could reuse.
- Full migration of a key domain entity to Entity Framework.
- Removal of 4 legacy stored procedures.
- Rewrites in the data-access layer and API to support the new path.
03 / 04
New integration capability
We opened a new front to automate accounting exchange with a third-party system, without waiting for the broader modernization to finish.
- SFTP integration with an external provider for accounting files covering advances and expense reports.
- Progressive refactor of the file generation flow.
- End-to-end coverage: from business logic down to automated processes and configuration.
04 / 04
Eight-dimension technical scorecard to prioritize modernization
We turned the system readout into scored artifacts the team could use to prioritize, not scattered notes.
- 19 analysis documents produced.
- A 30, 90, and 365 day roadmap for incremental modernization.
Visible impact in the first month
The first month produced results across three areas: execution speed, technical health, and the organization's ability to make better decisions going forward.
Execution impact
01 / 03The team was productive from the start, shipping real output while still learning the system.
commits during the period
24
of total repo output
45.3%
tasks addressed
4
- Agentify contributed 45.3% of the period's commits while operating as 2 developers inside a team with 6 active contributors.
- During the peak week, an Agentify developer was the single most active contributor across the whole team.
- Four workstreams ran in parallel: 3 were closed and 1 was still in progress at the time of the report.
Technical impact
02 / 03Beyond shipping fixes, we moved structural pieces that reduce friction going forward.
stored procedures removed
4
layers covered by delivery
6
of code touched in period
63.1%
- We touched the full stack -- from database to automated jobs and application -- rather than staying inside a single layer.
- The Entity Framework migration went from a vague intention to a working pattern that the team can repeat.
- The technical baseline replaced gut-feel assessments with a prioritized map of risk, dependencies, and maintainability.
Organizational impact
03 / 03We also reduced internal friction and left better conditions for the next cycle.
analysis documents
19
integrations mapped
16+
modernization roadmap
1
- Stakeholder interviews across business and operations reduced context loss between teams.
- The functional documentation we extracted and structured became reusable context for future development cycles, including AI-assisted work.
- The phased roadmap gave the organization a clear way to decide what to modernize first and why.
What we didn't solve in 30 days
One month is not enough to modernize an entire platform. We were honest about what stayed out of scope.
01
Test coverage is still at 0%. We prioritized delivery and baseline over testing because the team needed to see value fast.
02
The Entity Framework migration covered a single entity. The pattern is in place, but the volume of pending migration is still high.
03
The SFTP integration remained in progress. We opened the front, but it didn't reach production within the 30 days.
04
The documentation we produced organizes the next cycle, but it doesn't replace a continuous documentation strategy the team doesn't have yet.
Why this case matters
The difference here was straightforward: technical judgment, speed, and knowledge transfer from day one -- not a promise of some future transformation.
We work inside the real system
We entered the product as it already existed -- stakeholders, constraints, accumulated debt and all. No sandbox. No fictional backlog.
We diagnose while we ship
While building the technical baseline, we were also merging changes to production. That means stakeholders see value in weeks, not months.
Modernization starts before the big migration
Instead of promising a total rewrite, we moved one entity to Entity Framework, removed legacy stored procedures, and left a reusable pattern for the next phase.
We leave the team stronger than we found it
After interviews, context tooling, and 19 analysis documents, the knowledge that used to live in people's heads and chat threads was documented and accessible.
What comes next
The first month was never going to finish the full modernization. What it did was make the next steps clear and the pace of progress credible.
Complete the SFTP integration and sustain the pace on priority backlog.
Expand the Entity Framework migration pattern to 1 or 2 additional entities.
Introduce unit tests around migrated entities and enable mocking with interfaces where it has the most leverage.
Remove critical legacy dependencies and keep consolidating the path toward .NET 8+.
Ready for your case