From Theater President to Tech: Unexpected Leadership Lessons

When I tell fellow engineers that I spent two years as President of Theatron—the official theater club at Anna University—I usually get surprised looks. What does theater have to do with software engineering?

As it turns out: everything.

The Theater Club Context

Theatron wasn't a small operation. During my time as President (2023-2024), we:

• Staged multiple plays both on campus and at external venues
• Attracted 600+ audience members across productions
• Managed 20+ workshops for skill development
• Secured $3,000 in funding for competitions and productions

Leading this required skills that translate directly to tech leadership—skills I use every day as a software engineer.

Lesson 1: Managing Ambiguity

Theater productions are exercises in managed chaos. You have a script (maybe), a venue (hopefully), a cast (partially committed), and a deadline that's absolutely immovable: opening night.

Tech equivalent:
- Product spec (maybe)
- Infrastructure (hopefully)
- Team (partially available)
- Ship date that's absolutely immovable

In software, we often have ambiguous requirements, changing priorities, and team members pulled in multiple directions. The theater mindset—make progress with what you have, iterate constantly, prepare contingencies—serves engineers well.

Lesson 2: Shipping Under Pressure

Opening night arrives whether you're ready or not. There's no "we need two more weeks" in theater. The audience is in their seats.

This created a unique mindset:

• Prioritization becomes visceral: What absolutely must work vs. nice-to-haves
• Perfection is the enemy: A good show that happens beats a perfect show that doesn't
• Resilience under pressure: When things go wrong (they will), you adapt in real-time

I've carried this into software development. Deadlines are real. Sometimes you ship with known limitations and iterate. The key is knowing which corners can be cut and which are load-bearing.

Lesson 3: Stakeholder Management

Theater involves a remarkable number of stakeholders:

• Cast members: Each with their own schedules, skill levels, and motivations
• Crew: Lighting, sound, set design, costumes
• Venue coordinators: Rules, restrictions, availability
• Funding bodies: Expectations, reporting requirements
• Audience: The ultimate judge of success

Managing these relationships—keeping everyone aligned on the vision while respecting their constraints—is directly applicable to engineering work.

In tech, we manage:

• Team members: Each with their own workloads and expertise
• Cross-functional partners: Design, product, QA
• Infrastructure: AWS, CI/CD, monitoring systems
• Business stakeholders: Timelines, budget, priorities
• Users: The ultimate judge of success

The skills are identical. You're coordinating humans toward a shared outcome, managing expectations, and handling the inevitable conflicts that arise.

Lesson 4: Fundraising = Selling Your Vision

Securing $3,000 in funding required me to sell the vision of what Theatron could accomplish. Every pitch had to answer:

• Why does this matter?
• What will you do with the resources?
• What's the expected outcome?
• Why should I trust you to deliver?

Sound familiar? These are the same questions you answer when:

• Proposing a new technical initiative
• Requesting budget for tools or infrastructure
• Making a case for hiring
• Presenting to leadership

The ability to articulate value clearly and compellingly is transferable across every domain.

Lesson 5: Feedback Loops and Iteration

Theater has the most immediate feedback loop imaginable: live audience reaction.

During rehearsals, we'd constantly iterate:

• Try a scene interpretation
• Watch audience (other cast members) reaction
• Adjust based on what landed and what didn't
• Repeat until it worked

This is exactly how good software development works:

• Build a feature
• Watch user behavior
• Adjust based on data and feedback
• Iterate until it solves the problem

The speed might differ, but the principle is identical.

Lesson 6: The Show Must Go On

My most valuable theater lesson: resilience.

Things will go wrong. Actors forget lines. Props break. The lighting board crashes. In theater, you don't stop—you adapt and continue.

I've seen this translate directly to software:

• Production incident during a launch? Keep the service running while debugging.
• Critical bug discovered late? Work the problem, don't panic.
• Team member out sick before a deadline? Redistribute and deliver.

The theatrical mindset—that stopping isn't an option, that you find a way forward regardless—is invaluable in tech.

Applying These Lessons

Here's how theater leadership shows up in my engineering work:

During my AWS internship:

• Managed ambiguity around requirements for the GraphQL POC
• Shipped iteratively, getting feedback from partner teams
• Communicated progress to stakeholders with different technical backgrounds

On the NSF VR project:

• Coordinated across research and development priorities
• Managed scope when requirements evolved
• Delivered under academic timeline constraints

Building personal projects:

• Prioritized ruthlessly to ship working products
• Iterated based on user feedback
• Sold the vision to get collaborators excited

Advice for Engineers with Non-Traditional Backgrounds

If you have experience leading anything—clubs, teams, events, communities—don't dismiss those skills as irrelevant to tech. The core competencies of leadership transfer:

1. Communication: Translating complex ideas for different audiences
2. Prioritization: Deciding what matters most with limited resources
3. Resilience: Moving forward when things don't go as planned
4. Vision: Getting people excited about a shared goal
5. Execution: Actually delivering what you promised

These aren't soft skills—they're essential skills. Technical ability gets you in the door; leadership skills determine how far you go.

Conclusion

Two years of theater leadership taught me more about shipping under pressure, managing stakeholders, and leading through ambiguity than any classroom could. These experiences shaped how I approach software engineering—not just the code, but the collaboration, communication, and execution required to build great products.

If you're a student or early-career engineer: take on leadership roles outside tech. Run a club. Organize an event. Lead a team. The skills you develop will make you a better engineer.

---

Have an unexpected background that shaped your engineering career? I'd love to hear about it—reach out on LinkedIn.