Transforming an engineering team from ad-hoc to structured delivery

Company context

A content analytics platform helping creators and brands manage, analyze, and grow their audience. The team of 11 includes a CEO, deputy CEO, CTO, three operational leads (ops, customer success, growth), and five software engineers. The product runs on a complex stack: a Java API with Spring Batch, Node APIs, an Angular 13 admin frontend, a Laravel backend, and four coupled services with an orchestration layer.

The challenge

The engineering organization had grown organically without formal processes. The symptoms were everywhere:

Codebase health was critical. The technical debt ratio was 15%. There were 28 god classes violating single responsibility, 4,383 magic numbers hardcoded in business logic, nesting depth up to 13 levels, and 33 end-of-life dependencies. Unit test coverage was below 10%. No end-to-end tests existed for critical flows.

No structured development process. There were no development cycles, no sprint structure, no shaping process. Delivery timelines were frequently missed. Reactive work (bugs, support requests) constantly interrupted planned feature work. There were no WIP limits and no separation between maintenance and building.

Decisions disappeared. Key technical and product decisions were made in DMs and lost in Slack threads. No architecture decision records, no documented rationale. New team members had no way to understand why things were built the way they were.

Leadership was stretched thin. The CEO was spending over 30% of their time on operational work that should have been delegated. Role boundaries between the CEO, CTO, and operational leads were unclear. The head of ops did not know where to start her day. The head of growth was covering for another role without product knowledge, draining engineering time for questions.

Security gaps were real. The staging database used production data. There were hardcoded credentials in the codebase, secrets in Git history, weak password hashing, and no SAST/DAST in the CI pipeline.

What I did

Technical debt audit with automated monitoring.

I ran a comprehensive audit across six pillars: codebase, infrastructure, process, security, team, and UI/UX. The result was 208 individual debt items with a confirmed rate of 43% (89 items requiring action). Each item was scored by severity and mapped to the responsible team.

I built 15+ automated checks into a reusable scanner: Java and PHP AST analysis for complexity, god classes, swallowed exceptions, and nesting depth. Kibana integration for infrastructure checks (OS end-of-life versions, database storage utilization, uptime SLA). Security checks for credential patterns, SQL injection, XSS, and auth bypass risks. The scanner runs against the codebase and reports drift over time.

The overall health score was 2.86/5, with codebase (1.83/5) and team (1.30/5) in critical condition.

Performance audit on the Spring Batch application.

Analyzed the batch processing pipeline for concurrency bottlenecks, N+1 query patterns, memory leaks, and job orchestration inefficiencies. Produced a cost estimation document mapping each finding to remediation effort and expected performance gain.

Shape Up development cycles.

Introduced 6-week build cycles with 2-week cooldowns, based on the Shape Up methodology. Each cycle starts with a betting table where leadership picks the work. A circuit breaker rule kills bets that are not on track by week 4. Progress is tracked with hill charts instead of story points. Reactive work (bugs, support) runs on a separate track with its own Kanban board, WIP limits, and a weekly rotation for run duty.

Async work foundations.

Established communication norms: threaded discussions in dedicated per-bet channels, decision logging in a shared document, and no more decisions in DMs. This preserved context for the team and eliminated the "ask around to find out why" pattern.

AI-native engineering training.

Delivered a 1-hour workshop to all 11 team members on using AI coding agents in their daily workflow. The session covered test-driven development with AI, automated code review, pre-merge checks, and repository configuration. Each engineer ran a hands-on exercise. I configured 14 custom skills in their primary repository so the team could adopt AI-assisted development immediately.

Role clarity and delegation.

Wrote role definition documents for the CEO and CTO, mapping specific responsibilities and delegation targets. The goal was to reduce the CEO's operational contribution from 30% to under 15% by transferring ownership of day-to-day engineering decisions to the CTO and operational leads.

19 detailed execution plans.

Created a prioritized roadmap of 20 items spanning 6 months, each backed by a detailed plan file. The plans covered development cycles, async communication, issue triage, incident management, test coverage targets, development standards, on-call scheduling, and a strategy for freezing the legacy codebase in favor of a modular monolith architecture.

Results

This engagement is ongoing. Here is what has been delivered so far:

• Identified 208 technical debt items across 6 pillars with automated monitoring via 15+ scanner checks
• Overall health score established at 2.86/5 with clear per-pillar baselines for tracking improvement
• Performance audit completed on Spring Batch application with cost estimation and remediation roadmap
• Shape Up development cycles adopted: 6-week builds with betting table, circuit breaker, and hill charts
• Async communication norms established: per-bet channels, decision logging, no more DM-based decisions
• AI-native engineering workshop delivered to all 11 team members with 14 custom skills configured
• 19 detailed execution plans created covering process, engineering, people, and operations
• CEO operational contribution reduction plan in progress (target: under 15%)

What comes next: test coverage foundations (target: 80% on critical paths), legacy codebase freeze with modular monolith migration, incident management with formal severity classification and post-mortems, and operational excellence with SLA tracking and MTTR targets.

Testimonial

"We knew we had technical debt, but we could not see how deep it went. The audit gave us a clear picture for the first time. The development cycles and communication norms changed how the team works day to day. We went from reacting to everything to actually choosing what to build."