Let us take you back to the early days of YOUGotaGift.

It was a simpler time. A quieter time.

There were two or three heroic developers. These noble beings didn’t just wear multiple hats. They wore the whole wardrobe.

Front-end? Yes

Back-end? Yes

QA, Devops, Designer, IT Support, Office DJ, Office furniture mover? Yes, Yes, Yes Yes and Yes.

They would code, test and release everything by themselves, possibly while restarting the WiFi router, debugging the printer, and explaining for the fifth time that “Have you tried turning it off and on again?” is a valid solution. They even approved their own leaves, I heard.

In the beginning, things were chill.

There were, like , 5 tasks.

Everyone remembered everything.

Life was good.

But then, the company did something wild: it started to grow. Suddenly there were 20 tasks in the pipeline, 10 things in progress and 3 stakeholders asking, “Where is my feature?” and that's when the chaos hit, beautiful, legendary chaos. But Chaos, nonetheless.

Act 1: Chaos begin

As the task list grew longer than our office coffee bill, things started to fall through the cracks. The developers were drowning in code and couldn't keep track of everything. The tech lead, who was also buried under development work, tried to to juggle it all, but juggling flaming swords while blindfolded would have been easier.

Stakeholders started noticing that their precious requests were vanishing into the void (aka forgotten Slack messages) and developers began to suffer from chronic deadline amnesia.

Act 2 : Enter the Wise CTO

Our CTO looked at this glorious mess and asked the all-important question:

“If we can’t track 20 tasks now, how will we survive with 50 or more developers in the future?”

So under his leadership, the company started looking for “The Way”.

The Sacred Path.

The thing other companies seem to do but we weren’t doing.

And that’s when someone whispered the holy word: Project Management.

Act 3: The Agile Awakening

We started our deep dive into this mythical land called Agile. It said cool things like “Sprint” and “Scrum” and “iterations” and “burndown charts”(which we initially thought were something to do with Office snacks). We had no idea what any of it meant.

Turns out we weren’t alone in our struggles. So, we did what all great minds do: we Googled, we YouTubed and we stalked people from other companies and asked them- “How are you not panicking every day? Spill the tea “

Enter :JIRA

Ah, JIRA. Jira is simple, Jira is powerful, Jira is safe :)

– Said no one ever, while drowning in 38 open tickets, 3 missing subtasks, and a rogue epic that just reappeared out of nowhere.

(Okay fine, it’s a movie dialogue. But if Jira had a trailer, this would definitely be the tagline.)

So,

Yes, Jira is simple, also confusing enough to make us question our life choices. So naturally we started small.

We had just bought a shiny new JIRA subscription and was very excited about it - like adults buying a treadmill and immediately feeling healthier. The problem ? We absolutely had no idea how to use it efficiently. Or correctly. Or confidently. JIRA felt less like a project management tool and more like a Jigsaw puzzle designed by someone who enjoys adding extra pieces just to watch you suffer.

We didn't start running sprints immediately. Oh no. That would have required knowledge.

Our grand adventure began with creating stories and updating work items using JIRA’s default statuses. Click. Drag. Feel productive. Repeat.

We read about estimates too. It looked way too easy. Finally, our chance to confidently guess and look smart doing it. .

We guessed timelines like weather forecasts - boldly, publicly and wrong about 50% of the time. Some tasks took longer. Some took much longer. A few seemed to age gracefully while still “almost done”.

We thought adding tasks and estimates would solve everything.

Spoiler: it did not.

So, like any responsible team in mild panic, we Googled.. again. We watched videos ..again (Eternally grateful to Google, random bloggers and that one Youtube guy with 12 views who somehow saved us).

And then, like a plot twist in a sitcom, we stumbled upon something called a Sprint. Aha, light at the end of the backlog tunnel. That’s when we dug deeper, learned the ropes, and slowly, very slowly-started implementing sprint in our own quirky, but ever-improving way.

Act 4: One Problem solved, 10 more Appeared

At YOUGotaGift, we don’t just send presents- we also receive problems. Daily. With Love.

As our features grew, so did the plot twists. But hey- this is Project Management. We don’t fear blockers. We log them, assign them, and @someone into solving them.

• We planned Sprints in advance (big step) but Sprint plans were getting ruined by surprise “urgent” tasks like uninvited guests at a gift exchange.

So we assigned a poor soul- I mean a dedicated engineer, just to handle all those “Hey, can you just do this small thing?” mid-sprint requests.

• Our estimates? Gloriously wrong. Turns out you can’t squeeze 160 hours of work into a 40-hour week, no matter how optimistic the JIRA labels are.

So we brought in Capacity Tracker.

• PRDs that read like riddles from a confused wizard.

We added JIRA statuses to track every mystery in the backlog. Boom !

What are problems, if not just little gifts from the universe wrapped in panic and tagged “High priority”? And bit by bit , slowly, we started trapping these problems. It was a thing of beauty.

Act 5: Project Management gets serious

At this point, our developers were spending more time figuring out JIRA than writing code. It was killing productivity.

So we birthed a new legendary team : Project Management Administration(PMA)- our JIRA Wizards, Slack ninjas, and general saviors of sanity - “The Gift Wrappers” of all our messy processes. They didn’t come with a superhero cape, but with a Trello board and a Confluence doc template.

The PMA heroes took over JIRA setup, made tools talk to each other, and generally made the developers stop weeping over workflows. They made sure everyone has access, the set up is right, and that someone, somewhere is labeling things correctly (bless them).

Some of their behind the scenes magic includes:

JIRA Automations:

• No PRD on confluence? You’re not creating a story.

• Trying to sneak in a post-grooming PRD update? Nice try. The ticket is sealed tighter than grandma’s Tupperware

• Forgot to make QA subtasks ? Not anymore- it’s automatic now.

• Designs kept changing mid-sprint? Adding versioned design links to the PRD was made mandatory.

Smarter workflows:

PMA introduced logic into our JIRA workflows with our CTO’s supervision. No more floating tickets or existential status labels like “Review-ish.” Every movement now makes sense- even to people who read nothing but the Slack thread.

No more Babysitting tickets

Tickets now follow escalations, priorities, and structure like well-trained ducks. PMA made the ticketing system clear enough that even your work bestie who “hates tools” can follow it.

Confluenced everything

Everything lives on Confluence now- because if it's not written down, it doesn’t exist.

Thanks to PMA, this documentation paradise now includes:

• Product admin guides

• Feature walkthroughs

• Operational Playbooks

• Jira workflows

• Architecture Diagrams

• That one doc we pretend to update every quarter but mostly don’t

And yes, it’s all searchable. No more “Can you DM me that doc again?” ever again. In fact, we have recently published all these guides on our portals with AI search- so finding the right document is now faster than a developer blaming the server for their code not working.

GitHub, But Make It Orderly

All code is stored on GitHub, where it's beautifully versioned, secure, and traceable from commit to production. PMA doesn’t write the code, but they make sure no one gets lost between the branches. Literally.

Slack: Where Everything Happens, but Properly

Slack isn’t just a chat app- it’s our central nervous system.

Project initiation? In threads.

Stakeholder questions? Tagged and tracked.

Unclear feedback? Achieved in 17 different places.

PMA doesn’t answer your Slack questions.

They just make sure the process for how to ask, answer, and escalate exists.

Which, let's be honest, is even better.

Thanks to them, our tools- Slack, Confluence, JIRA, Github, Trello don’t just sit around looking pretty. They actually work. Together. In harmony. Well, most of the time.

Back to chaos time :)

But chaos wasn’t fully defeated. There were still conflicts-

People were arguing.

Stakeholders wanted updates.

Developers needed something or the other from the product team

One tech team had dependency on multiple other teams.

The company wanted peace.

It was like a version of a reality show.

so we did the only thing to do.

Act 6: Summon the PM Superstars→ Project Management Office (PMO)

Project Managers entered the YOUGotaGift scene like gift cards during the holidays- unexpected, shiny and exactly what we needed.

Trained in the ancient arts of timelines, follow-ups, and “Why is this still in To do?”, they were here to enforce the processes we spent years evolving.

Their job?

• Make sure Sprints are actually finished.
• Ensure teams followed structure.
• Help track developer capacity without creepily stalking their calendars.
• Prevent random urgent tasks from derailing the entire roadmap.
• Create more processes to stop future chaos.
• Remove blockers like “We can’t start because the button hasn’t been approved yet”.
• Be the official status announcer for all Stakeholders.
• Jump in when things are on fire
• Make sure timelines don’t stretch into the next century
• Manage resource constraints and made sure no team is sitting idle at any time.
• Give training to project teams
• And finally - ask “Is this task updated on JIRA, is your time logged?” 52 times a day

And yes, sometimes they also:

• Play therapist.

• Translate stakeholder language into developer speak and vice versa.

• And very politely chase people who are ignoring their tasks.

If we can Group Gift a digital surprise across countries in seconds, surely we can plan a sprint that doesn’t implode by Day 2.. Right ?

Now that our Project Managers were out there managing timelines, taming stakeholders, and juggling requirements likes pros, it was time to bring in their wise older cousin: the PMO (Project Management Office)

The PMO team isn’t about the daily ticket drama. They are the ones setting the stage, building the rules, and making sure no one runs off with the production server.

Here’s what they really do

• Set up and maintain Project management standards - because chaos is only fun in sitcoms.
• Support project teams, so they don't drown in status meetings, and spreadsheet tabs
• Align every project with YOUGotaGift’s big picture goals - no rogue side quests allowed.
• Handle strategic planning, resource balancing and governance (a fancy word for “please follow the process!”).
• Prioritise projects like a kid at a store, but with more meetings.
• Develop project methodologies, so people stop making it up as they go.
• Make sure all teams speak the same language: “On time”, Within scope”, and “Who approved this?”
• Manage risks, issues and occasional emotional breakdown (usually over timelines).
• Ensure quality, consistency, and that no one skips UAT “just this once”.
• Oversee formal project closure - because “it's done” means more than pushing to prod.
• Evaluate project outcomes so we learn, improve, and avoid repeating the same mistakes.

In short, they make sure project management isn’t just vibes.

When PMO dreamed, PMA delivered

So the PMO team and the PMA team worked together in perfect harmony, assembling processes like IKEA furniture- with enough instructions that even developers could follow it.

The PMO team listened patiently to every product tweak and requests, every tech blocker, and every stakeholders’s “urgent-but-not-urgent” escalation. Then, they analysed it all, figured out how it fit into our growing ecosystem, and translated it into something the PMA team could build into real processes.

The PMA team didn’t invent the rules- they just made them happen.

Whether the idea came from the CTO, Product team or the project managers, the PMA team would quietly take the requirement, roll off their sleeves and turn it into a working system.

One workflow at a time, things got smoother, smarter, and finally.. It made sense.

Scaling up Without Losing Our Minds (or tickets)

We didn’t just scale teams - we scaled systems, security, and sanity.

Today, we run with:

• Multiple microservices, each minding their own business.

• Multiple engineering squads working in parallel, yet somehow not breaking each other’s stuff (we’re amazed too)

• A fully automated QA system that doesn’t sleep, blink, or miss edge cases

• Security tools like Burp Suite and Static Application Security Testing (SAST) platforms that sniff out threats faster than a dev can say “it worked on my machine!”

All of this, of course, runs on the backbone of processes built and managed by the PMO and PMA teams. Because tools are only as good as the humans who set the rules, configure the chaos, and say, “NO, you can’t skip the PRD.”

Final Act : The present Day- A new Hope

Today we are a whole new beast, a beautiful well oiled, slightly caffeinated machine.

So how do we run a larger engineering team now?

With a mix of:

• Clear ownership across product, tech, and project teams
• Tools like JIRA, Confluence, Slack, Trello and Miro (ref - Stack | Engineering | YOUGotaGift )
• Centralized documentation and workflows
• Secure, traceable deployment flows via GitHub
• Priority based escalation channels, not vibes
• Processes that scale with people, not just tickets
• Sprint Management that(mostly) works
• Proper incident management system.
• Ticketing systems to handle ad hoc madness.
• Clear PRD with versioned designs
• A full fledged Project Management department that keeps the ship sailing

Now, there are no more accidental deployments, no more floating PRDs, and definitely no more “where’s the Figma link?”

Best of all- our developers can finally develop, and the rest of us can stop asking, “Wait, who is supposed to do this again?”

And behind every successful sprint is a PMO (Project Management Officer) quietly updating the Stakeholder, fixing the blocker, and yelling in their head,

“WHY IS THE STATUS OF THIS TASK STILL NOT CHANGED?!”

And yes, you might wonder - do we really need all these systems? Absolutely not. YGG could have survived without it, but sailing a boat with a light is always better than sailing without one.

Well, we now have a knowledge base so powerful, it's like a second brain that answers questions in minutes, gives instant summaries, and remembers a decade's worth of our glorious mistakes.. I mean knowledge.

Over the years, our accumulated docs, defined PRDs, and processes have all gained AI superpowers.

And yes..just like that, we have gone from “YOUGotaGift… of chaos” to

“YOUGotaGift… of solid Project Management”.

And yes, while we still occasionally miss deadlines, at least now we know why.

Because it’s documented.

On JIRA.

With a common thread.

And a status.

And a sub-task.

And a Confluence link to the PRD.

And probably a smiling emoji.

And we still Google stuff occasionally, but now it's less “How to prevent Sprint spillovers” and more “Funny project management Memes.”

So,

Got a team in havoc? Want to go from sticky notes to scalable workflows?

We’ve been there. We survived. And we gift-wrapped the survival guide for you.

Want to know how we did it?

Ping us. Pick our brains. Or just tag us in your favourite “Agile gone wrong” meme.