Software development projects are unlike any other. They’re complex, iterative, and deeply collaborative—requiring not only technical execution but a high level of coordination between engineers, stakeholders, and business goals. For IT project managers, especially those without a technical background, managing these projects effectively can be challenging.

From navigating vague requirements to estimating timelines for tasks that haven’t been done before, managing engineering teams demands a unique toolkit. This article outlines actionable best practices for IT project managers, focusing on the real-world challenges of managing software development teams.

Understand the Nature of Software Development

Software isn’t built like a bridge—it’s more like writing a novel. There are often multiple paths to the same goal, unknowns that emerge mid-project, and feedback loops that require flexibility.

Why this matters:

  • Requirements evolve as users test early versions.
  • Developers uncover unforeseen technical constraints.
  • The work is often experimental, especially in startups or innovation-driven environments.

What you can do:Adopt an iterative mindset. Embrace Agile principles—not just the ceremonies, but the idea of continuous learning, course correction, and collaborative problem-solving. Don’t expect certainty where it doesn’t exist.

Estimation is Hard—So Make It Collaborative

Timeline estimation is notoriously difficult in software development. Even seasoned developers can struggle to forecast how long a task will take due to unknown dependencies, integration challenges, or legacy code issues.

Techniques to try:

Planning Poker

A group estimation technique used in Agile teams where each developer uses a deck of cards (or digital equivalent) to estimate the effort of a user story or task. Everyone reveals their estimate at the same time, prompting discussion when there’s a wide range of opinions.

Why it works:

  • Encourages diverse viewpoints
  • Surfaces hidden complexities
  • Builds consensus through discussion

T-shirt Sizing

Tasks are sized into categories like XS, S, M, L, XL instead of specific hours or days. This is useful early in the project when details are light.

Why it works:

  • Faster than detailed time estimates
  • Focuses on relative complexity
  • Avoids false precision early on

Key practice:Always factor in uncertainty. Encourage developers to be honest about what they know and don’t know. It’s better to over-communicate uncertainty than to set unrealistic deadlines.

The Power of a Clear PRD and Well-Written Tickets

The Product Requirements Document (PRD)

A strong PRD (Product Requirements Document) clearly outlines:

  • What is being built
  • Why it matters (business context)
  • Key success metrics
  • User stories or scenarios
  • Acceptance criteria

Impact: A well-structured PRD aligns the development team, product manager, and stakeholders. It minimizes rework by eliminating ambiguity and helps developers make better decisions independently. The product manager usually writes the PRD, but as a project manager, you should monitor changes and ensure that they’re communicated to the team.

The Role of the Tech Lead in Ticket Writing

Once the PRD is in place, having the tech lead write technical tickets that break down the work is essential. These tickets typically include:

Impact:

  • Developers know exactly what is expected.
  • Reduces back-and-forth during development.
  • Improves estimation accuracy.
  • Allows junior developers to contribute more confidently.

When tech leads take time to write thoughtful tickets, they’re effectively creating a roadmap the rest of the team can follow.

Software Development | Managing Without a Technical Background

It’s entirely possible to lead a high-performing dev team without writing code. But you must be curious, humble, and proactive in learning the basics.

How to add value:

  • Focus on clarity. Help teams understand business context and customer needs.
  • Ask questions. “How can I help?” Is there someone you’d like me to contact? 
  • Translate requirements. Ensure what stakeholders want is captured in a way developers understand.
  • Partner with a tech lead. Rely on them to validate technical feasibility and define how work should be approached.

Tip: You don’t need to code, but understanding workflows helps you speak the team’s language.

Set and Reinforce Team Norms

Successful software teams aren’t just smart—they’re aligned. Norms create a shared understanding of how work happens.

Examples of helpful norms:

  • Code reviews are required before merging code.
  • Meetings start on time and follow an agenda.
  • Everyone updates their tickets daily.
  • Deep work hours are protected (e.g., no meetings before noon).

Why this matters:Team norms reduce friction, prevent burnout, and foster accountability. As a PM, you’re in a great position to advocate for these norms and gently enforce them.

Track Velocity, But Don’t Obsess

Velocity (e.g., story points completed per sprint) is useful for planning—but it’s not a performance metric.

Use velocity to:

  • Forecast future work more accurately
  • Identify trends over time
  • Spot when the team is overcommitting or underdelivering

Don’t use velocity to:

  • Compare individuals
  • Push teams to “go faster”
  • Tie to compensation or performance reviews

Warning signs:

  • Story points increase without better outcomes
  • Developers game the system by inflating estimates

Track velocity, but keep the focus on delivering real value—not just output.

Encourage Collaboration and Cross-Functional Communication

Even the best developers can become siloed. Project managers play a key role in creating bridges between people, disciplines, and perspectives.

Best practices:

  • Use Agile ceremonies intentionally. Make retrospectives a space for improvement, not just a checkbox.
  • Promote pairing or mob programming. Especially when onboarding new team members or tackling tough bugs.
  • Bridge business and technical teams. Translate business goals into technical priorities and vice versa.

Your job as a PM: Be the glue. Clarify misunderstandings, surface blockers early, and ensure everyone is rowing in the same direction.

Use Tools Thoughtfully, Not Excessively

The right tools can reduce friction—but too many tools create confusion.

Essential tools for PMs:

  • Backlog and sprint tracking – Monday.com, Github projects, Asana, Jira
  • Documentation –  MS word, Google Docs, Notion 
  • Communication – Slack, MS Teams

Key advice:

  • Automate status reporting where possible (e.g., Jira dashboards).
  • Don’t micromanage through tools—use them to enable visibility and trust.
  • Standardize workflows (e.g., ticket statuses, labels) to keep things clear.

Conclusion

Managing a software development team as an IT project manager means balancing structure with flexibility, and oversight with empowerment. You don’t need to know how to code—but you do need to understand how developers work, what they need to succeed, and how to remove obstacles in their path.

By championing clear documentation, fostering collaborative estimation, setting team norms, and focusing on outcomes over outputs, you can create a high-performing environment where engineers do their best work—and your projects deliver real value.