Someone was always starting their day while someone else was finishing it. Meetings became awkward. Decisions waited overnight. Questions sat unanswered for hours.

The obvious solution was to ask people to work outside their normal hours.

The better solution turned out to be AI.

Over the past few months I’ve been experimenting with using ChatGPT as more than just an assistant for writing or coding. It’s become the coordinator that keeps work moving while people quite rightly aren’t working.

The result hasn’t been people working longer.

It’s been the team working smarter.

Time Zones Aren’t the Problem

Most organisations see geography as the challenge.

I don’t.

The real problem is context.

When someone in the UK hands work to someone in Australia, or vice versa, valuable time is often lost explaining where things are, what has changed, what’s already been tried and what the expected outcome looks like.

By the time everyone has caught up, another half day has disappeared.

AI removes much of that friction.

Instead of writing lengthy handover emails, I can ask ChatGPT to produce concise, structured updates tailored to the recipient.

It captures decisions, identifies blockers, highlights risks and creates clear next actions.

The receiving engineer starts with understanding instead of detective work.

The AI Project Coordinator

One of the biggest mindset shifts I’ve made is treating ChatGPT as another member of the team.

Not because it replaces anyone.

Because it remembers everything better than I do.

Throughout the day I ask it to:

• summarise meetings
• capture decisions
• identify outstanding actions
• produce status updates
• draft communications
• highlight dependencies

By the time another region starts work, I already have a polished handover that would previously have taken twenty minutes to write.

Multiply that across an entire week and the time savings become significant.

Scheduling the Right Work at the Right Time

One feature that has quietly become invaluable is ChatGPT’s scheduling capability.

Rather than trying to remember to prepare updates, review priorities or check progress, I simply schedule those activities.

Every morning I receive a concise briefing.

Before key meetings I receive preparation notes.

At the end of the day I receive prompts to capture outstanding decisions while they’re still fresh.

These aren’t reminders in the traditional sense.

They’re intelligent checkpoints that keep work flowing.

The important distinction is that AI isn’t telling me what to do.

It’s reducing the effort required to stay organised.

Creating a Longer Working Day

The interesting outcome isn’t that anyone works more hours.

They don’t.

Instead, the effective working day becomes much longer.

When my day finishes, someone else’s begins.

Instead of leaving them with incomplete notes, AI helps package everything they need to continue immediately.

While they’re making progress, scheduled summaries and updates keep me informed without interrupting their work.

By the time I log back on the following morning, decisions have been made, issues have moved forward and priorities are already clear.

The clock never stopped.

The people simply maintained healthy working hours.

Less Administration, More Leadership

One unexpected benefit has been the amount of management overhead that’s disappeared.

Instead of spending time preparing updates, consolidating notes and chasing status reports, I spend more time solving problems and supporting the team.

That’s where leaders create value.

AI is quietly taking care of much of the administrative glue that traditionally filled the gaps between conversations.

AI Isn’t Replacing Teamwork

There’s a lot of discussion about AI replacing people.

That’s not what I’m seeing.

What I’m seeing is AI removing the delays that prevent talented people from collaborating effectively.

It doesn’t make better decisions than my engineers.

It simply ensures they have the right information at the right time.

The human expertise is exactly where it has always been.

AI just keeps it moving.

Final Thoughts

The biggest productivity gain I’ve seen from AI hasn’t come from writing faster or creating documents more quickly.

It’s come from improving the flow of work.

When information moves seamlessly between people, across time zones and throughout the working day, the entire team becomes more effective.

Nobody works longer.

Nobody attends more meetings.

Nobody needs another collaboration tool.

Instead, AI quietly fills the gaps between conversations, keeping momentum alive long after the office lights have been switched off.

There was a time when my phone looked like a showcase for “productivity”.

Task managers. Note taking apps. Whiteboard apps. Mind mapping tools. Team dashboards. To-do lists. Habit trackers. Time trackers. Document apps. AI assistants. Collaboration tools. Communication platforms.

Twelve apps. Twelve different notifications. Twelve different places where “important” things lived.

And honestly? Most of them were just layers between me and actually getting things done.

Over the last few months I’ve been quietly simplifying how I work whilst away from my desk, and the result has been surprisingly dramatic. I’ve removed twelve productivity apps from my mobile device and replaced them with just three core tools:

• Outlook
• Teams
• ChatGPT

That’s it.

The Death of the Mobile Productivity Stack

The original promise of productivity apps was compelling:

“Capture everything.”
“Organise your life.”
“Never forget anything.”
“Manage work from anywhere.”

The problem is that most apps became destinations rather than assistants.

You didn’t just do work anymore — you had to maintain the system that managed the work.

Tasks needed tagging.
Notes needed organising.
Boards needed updating.
Projects needed grooming.
Templates needed maintaining.

At some point, I realised I was spending more time curating productivity than benefiting from it.

AI Changed the Equation

The big shift for me was the arrival of genuinely useful AI workflows.

Before AI, structure mattered because software was rigid. If information wasn’t in exactly the right place, the tool became ineffective.

Now? Context matters more than structure.

ChatGPT can summarise.
It can extract actions.
It can draft responses.
It can organise thoughts.
It can build plans from unstructured conversations.
It can act as the connective tissue between fragmented information sources.

That fundamentally changes how many apps you actually need.

My Current Mobile Workflow

Outlook Becomes the Command Centre

Outlook handles:

• Email
• Calendar
• Meeting prep
• Quick approvals
• Team visibility
• Prioritisation

Instead of exporting information into other systems, I now leave far more information where it naturally originates.

An email thread is often the project history.
A meeting invite is often the task list.
A flagged message is often enough of a reminder.

AI helps process information rather than forcing me to relocate it.

Teams Handles Operational Awareness

Teams has effectively replaced several standalone collaboration tools for me.

I use it for:

• Team communication
• Status updates
• Quick decision making
• File access
• Incident coordination

But more importantly, Teams gives me context.

That matters far more than maintaining a perfect task hierarchy on a mobile screen.

ChatGPT Is the Workflow Multiplier

This is the real difference maker.

ChatGPT has become:

• My mobile thinking partner
• My summarisation engine
• My drafting assistant
• My prioritisation tool
• My “turn chaos into clarity” system

Instead of opening five apps to:

• capture notes,
• organise tasks,
• draft emails,
• create summaries,
• and prepare updates…

…I can now simply describe what I need.

For example:

“Summarise today’s customer escalation thread and produce actions for tomorrow.”

Or:

“Turn these rough notes into a structured update for leadership.”

Or:

“What are the key risks emerging from these conversations?”

That workflow reduction is enormous.

Fewer Apps = Less Friction

What surprised me most wasn’t just convenience.

It was cognitive reduction.

Fewer icons.
Fewer notifications.
Fewer disconnected systems.
Fewer decisions about where information belongs.

My phone now feels like a communication and decision-making tool again rather than a miniature admin console.

There’s also something slightly ironic happening in the productivity software industry:
AI is making many productivity apps less necessary.

A lot of tools existed primarily because humans had to manually structure information for software to understand it.

Now software understands messy human input much better.

That changes everything.

Mobile Work Should Be Lightweight

I still believe deep work belongs on a proper workstation.

But mobile work?
That should be:

• responsive,
• lightweight,
• contextual,
• and fast.

The goal isn’t to recreate your desktop workflow on a six-inch screen.

The goal is to stay informed, unblock people, make decisions, and keep momentum moving.

Right now, Outlook + Teams + ChatGPT does that better for me than twelve fragmented productivity apps ever did.

And honestly, I don’t miss any of them.

Over the past few weeks, I’ve been deliberately exploring how AI can support real-world software delivery—not as a novelty, but as a practical tool embedded into day-to-day engineering work.

This hasn’t been about generating code for the sake of it. Instead, it’s been about applying AI across different types of ownership, complexity, and lifecycle stages of software. What’s emerged is a clearer picture: AI is most valuable not when it replaces development, but when it accelerates understanding, improves quality, and reduces friction.

Here’s how that has played out in practice.

1. Improving Code I Already Own

The easiest place to start was with code I had written myself—tools that are already in use and solving real problems.

Because I understood the intent and behaviour of these applications, AI became a powerful second pair of eyes. I used it to:

• Generate unit tests for areas that had little or no coverage
• Identify gaps in build and deployment pipelines
• Highlight potential security concerns
• Suggest refactoring opportunities for readability and maintainability

The result wasn’t dramatic rewrites. Instead, it was steady, compounding improvement:

• Higher confidence in changes due to better test coverage
• More reliable builds and deployments
• Reduced time spent on manual code reviews
• Cleaner, more maintainable codebases

This is where AI felt most immediately productive—augmenting existing knowledge rather than trying to replace it.

2. Making Sense of Legacy Systems

A more interesting challenge came from systems I hadn’t written—particularly those with limited documentation and where historical knowledge had faded over time.

Here, AI acted less like a coding assistant and more like a translation layer.

I used it to:

• Analyse unfamiliar code and explain intent
• Generate technical documentation from existing implementations
• Identify outdated dependencies and suggest upgrade paths
• Propose test strategies for systems that had none

What would typically take days of manual exploration could be accelerated significantly. More importantly, it reduced the risk of “guesswork engineering”—making changes without fully understanding the system.

Key outcomes included:

• Faster onboarding into legacy systems
• Improved stability through better understanding
• Reduced reliance on tribal knowledge
• A foundation for future modernisation

This was one of the most valuable use cases: turning unknown systems into known ones.

3. Tailoring the Tools I Use Every Day

Another unexpected benefit came from applying AI to open-source tools I use regularly.

Instead of working around limitations or minor frustrations, I was able to:

• Explore the codebase quickly
• Identify the root cause of issues
• Implement targeted fixes or enhancements

AI reduced the barrier to entry for modifying third-party code. Tasks that might previously have felt too time-consuming or complex became achievable in a short space of time.

The impact here was subtle but meaningful:

• Smoother day-to-day workflows
• Faster resolution of small but persistent issues
• Greater control over the tools I rely on

It shifted the mindset from “adapting to tools” to “adapting tools to fit the way I work.”

4. Reviving Older, Customer-Facing Solutions

Some of the most challenging scenarios involved older solutions that are still in use but no longer actively developed.

These tend to surface through support cases or escalations, often requiring rapid understanding and targeted fixes.

AI proved particularly useful in:

• Interpreting older coding patterns and structures
• Diagnosing issues from limited context
• Suggesting safe, minimal changes to resolve problems
• Documenting behaviour that had never been formally captured

This led to:

• Faster resolution times for complex issues
• Fewer repeat incidents
• Increased confidence when working in fragile codebases

Rather than treating these systems as untouchable, AI made them accessible again.

5. Enhancing Actively Maintained Solutions

Finally, I applied the same approaches to modern, actively maintained solutions—where expectations around quality, security, and consistency are much higher.

In this space, AI supported:

• Continuous improvement of test coverage
• Ongoing security reviews
• Documentation generation and updates
• Ensuring alignment with current platform standards

The key difference here is that AI becomes part of the development lifecycle, not just a one-off tool.

Benefits included:

• More consistent quality across releases
• Faster delivery of enhancements
• Improved confidence in production changes
• Better alignment with evolving standards

This is where AI starts to feel like a long-term capability rather than a short-term productivity boost.

What I’ve Learned

Across all of these scenarios, a few consistent themes have emerged.

1. AI Accelerates Understanding More Than It Replaces Thinking

The biggest gains came from reducing the time it takes to understand code—not from blindly generating it.

2. Context Still Matters

AI is most effective when you can validate its output. The better your understanding of the system, the more value you get.

3. Small Improvements Compound Quickly

Adding tests, improving pipelines, and tightening security might seem incremental, but together they significantly improve delivery confidence.

4. Legacy Work Is Where AI Shines

The less documented and more complex a system is, the more impact AI can have in making it accessible again.

5. It Changes What Feels “Worth Doing”

Tasks that previously felt too time-consuming—like fixing minor issues in third-party tools or documenting old systems—suddenly become viable.

Where This Goes Next

This is still early in the journey, but the direction is clear.

AI is not just a coding assistant—it’s becoming a core part of how we:

• Understand systems
• Maintain quality
• Reduce risk
• Deliver improvements faster

The next step is to move from individual use to repeatable patterns—embedding these approaches into team workflows, standards, and expectations.

Because the real value isn’t just in what AI can do—it’s in how consistently we can apply it.

The 2026 Resolution: The “Tech-Powered” Human
While my new neck discs are a feat of medical engineering, they’ve inspired me to look at how I can use technology in other areas of my life. My resolution for 2026 isn’t about “doing more”—it’s about leveraging technology to be more present.
After a year of pushing through pain, I want to use the tools available to me to boost my efficiency while protecting my health. Here is how I’m planning to fuel my comeback:
Boosting Family Life: I’m leaning into smart-home automation and shared digital planning to remove the “mental load” of household management. By letting tech handle the grocery lists and schedules, I can focus 100% on being present with my family as I recover.

Healing with Intent
This year is going to look a little different. There will be physical therapy, plenty of rest, and a steady climb back to full strength. But with 12 months of pain finally behind me and two new discs to support me, I’ve never felt more optimistic.
Recovery isn’t just about getting back to “normal”; it’s about building a life that is more balanced and intentional than before. Here’s to a 2026 that is tech-enabled, family-focused, and—most importantly—moving forward.

“The goal isn’t just to heal, but to thrive.”

If I had to give 2025 a headline, it would be change with purpose. This year stretched me in the best ways—stepping into new leadership responsibilities, growing a team, tightening the way we ship, and learning to listen harder than I speak. Here’s the personal version of that story—no brand names, no customer specifics—just what changed in me and how I showed up.

Stepping Up: The Promotion That Changed My Calendar (and Mindset)

Early in the year I moved into a bigger role. The real shift wasn’t the title; it was the lens. I stopped optimising only for “what I can build” and started optimising for “what the team can deliver repeatedly.”
That meant trading some deep maker time for clearer goals, sharper priorities, and better guardrails. I learned that great leadership isn’t louder—it’s more consistent.

Building the Team: Capability Before Headcount

I focused on capability first: the skills we need, the outcomes we own, and the habits that make our work sustainable. Then I hired for those.
Recruiting became less about “finding a unicorn” and more about complementary strengths: pairing systems thinkers with strong communicators, matching builders with patient debuggers, and balancing speed with steadiness. The win wasn’t filling seats—it was creating a team that could cover for each other and still raise the bar.

Shipping More (and Smarter): Extensions That Reduce Friction

This was a shipping year. We delivered and refreshed a number of small-but-mighty extensions that simplify everyday workflows—things that make sending, tracking, auditing, and revising feel lighter.
My guiding principle was simple: remove one step, add one check. Fewer clicks, clearer states, better logs. The result was a set of releases that felt invisible in the best way: they just worked.

How we kept momentum:

• Micro‑sprints: fifteen‑minute weekly checkpoints to unblock decisions fast.
• One‑page runbooks: enough guidance to get anyone productive, without a wall of text.
• “Prove it’s live” checks: lightweight verification steps built into our deployment flow.

Owning the Plumbing: Pipelines, Permissions, and Environment Boundaries

Shipping more forced me to become a student of the plumbing—credentials, pipelines, environments, and deployment rights. When automation faltered, I documented a clear manual path to production with artefact verification and rollback notes.
I also nudged us toward true test vs. production separation, tightened access, and wrote down the things future‑me would otherwise forget. Unsexy work, essential outcomes.

Raising the Floor: Security, Compliance, and Clarity

Trust isn’t a feature you bolt on—it’s a minimum standard you live by.
This year I helped translate policy into practice: tightening recording rules for sessions, clarifying what AI tools are appropriate in meetings, and setting sensible defaults that make safe behaviour the path of least resistance.
I learned to treat security as an experience challenge: make the right thing obvious, quick, and documented.

Listening More: Field Signals, Release Notes, and Community Threads

A big part of my growth was learning to listen for signal—especially from upgrade notes and practitioner conversations. Those discussions surfaced tiny changes in behaviour that could become big friction later.
By folding that feedback into our defaults and help text, we prevented issues from turning into tickets. Quiet wins are still wins.

What Changed in Me

• From fixes to systems: I stopped “hero‑patching” and started designing repeatable ways to prevent the same issues.
• From shipping to safeguarding: I now see deployments as both delivery and defence—verify, limit blast radius, document.
• From speaking to listening: Feedback isn’t noise; it’s an early warning system if you’re humble enough to hear it.

The Quiet Wins I’m Proud Of

• A deployment playbook that works even when automation doesn’t—with verification built in.
• Extensions that reduce friction and feel intuitive—less clicking, clearer states, better audit trails.
• Policies translated into practical steps—not just rules, but workflows anyone can follow.

Looking Ahead to 2026

Next year is about consistency at scale: fully automated pipelines, cleaner environment boundaries, and guardrails that make secure, compliant delivery the default. My personal goal is to spend more time coaching and documenting, so the team can move faster with fewer surprises.

Thanks for reading—and for being part of the change. If this year taught me anything, it’s that growth isn’t about doing more; it’s about doing the right things, repeatedly, together.

Everyone knows the negatives of 2020, I won’t list them, there are many. However, we, as a human race, tend to focus on the negatives too much, so I will list some positives to think about as we head towards 2021. Pandora’s box has opened, now it’s time to find the glimmer of hope.

2020 saw achievements by many, some of these were driven by need and necessity, others were years in the making. And, whilst the year as a whole may have taken the shine off them, we should celebrate them.

• We sent people into space, on a reusable rocket and capsule. – https://www.youtube.com/watch?v=E_FIaPBOJgc
• Scientists worked at incredible rates to work on a vaccine for Covid-19, resulting (at this point in time) in at least 3 or 4 viable vaccines that could be available to the public before the year ends. – https://www.wired.co.uk/article/coronavirus-vaccines
• Innovation and the ability to adapt has meant that whilst some companies folded, and many individuals have sadly lost their jobs or been furloughed, some companies were smart enough to rise to the challenge. Digital Transformation strategies and utilisation of technology have helped lots of companies overcome the challenge, in some cases increase their output, or in other cases adapt their products and services to meet new demands. In the UK, for example, we had many manufacturing companies come together to use their dormant machinery to make ventilators, PPE, girders for temporary hospitals, etc.
• We are still here. The planet hasn’t been totally destroyed, and whilst our mental health teeters on the edge, many of us have found a new appreciation for those around us whilst learning new techniques and behaviours for getting through the day, week, month, and year. It is these new found skills and attitudes to life that will see us in good stead for the years ahead, whether the next event is closer to home, or on a global scale.

Ok, so not going to lie, I struggled to find enough positive stories from this year, but those above are the ones I believe in, the ones that have peaked my interests and allowed me to have some positive vibes to get through.

On a personal/career level, 2020 was supposed to be a year of self-discovery and development. Starting a new role in October 2019 with a brand new remit and direction was incredibly scary, but a challenge I relished. Fortunately, that role survived the turmoil around Covid-19 and I’m still here to tell many tales. I have been able to upskill, adding to my “jack of all trades” mantra that sees me now capable of some very interesting and potentially dangerous things, as well as embedding myself into a well established and very experienced team, relatively seamlessly. 2021 will see me continue in this role, with the same people and adding various activities along the way. I am glad for this consistency in my work life as the world around us continues to be so unpredictable.

https://www.epicor.com/en-uk/press-room/news-releases/clayton-dubilier-rice-to-acquire-epicor-software-corporation-from-kkr/

On a personal note this will be the 4th acquisition/takeover/purchase of a company I work for in 5 years, see previous posts for notes on those!

I wanted to share my findings, rather than my code at this stage, and here are my Top 5 SendGrid tips:

1. Do review Microsoft’s guide on how to get started with SendGrid via Azure, this simple article gives you a great base on how to set up the back-end and start writing C# around it: https://docs.microsoft.com/en-us/azure/sendgrid-dotnet-how-to-send-email
2. Use Unsubscribe groups – these allow you to stay within GDPR in Europe, appending an Unsubscribe and Manage Preferences link to the bottom of the emails that are sent. i.e.

3. Write both plain text and HTML content for your email, I ended up creating an HTML builder so I could convert Email addresses to <a href="mailto:EmailAddress"> and any HTTP(s):// links to <a href:"http://link"> this was a great experiment with regular expressions. Note, I found that not all Email clients auto-convert, e.g. Outlook will convert an Email address but not a URL. I was creating my body text in a Rich Text Box, so it was just one big string!
4. Look into Personalisations (https://sendgrid.com/docs/for-developers/sending-email/personalizations/) these are crucial if you want to customise your output (the emails themselves). I created variables to use in subject and body lines so I could pass in {customer} and {product}. SendGrid has a substitution capability which comes as part of personalisation. I’ll share a snippet of code here, as I found a solution on StackOverflow (https://stackoverflow.com/a/53292550) but it needed a slight tweak, changing the Tos.Add to a msg.AddTo as the To: Email address needs to be a part of the personalisation, I wasn’t sure if this was to do with API changes or not! Another tip, if you want the subject to be the same, without substitutions you can use the SetGlobalSubject method

var personalizationIndex = 0;
                foreach (var subscriber in subscriberEntities)
                {
                    msg.AddTo(new EmailAddress(subscriber.RowKey, subscriber.Name), personalizationIndex);
                    msg.AddSubstitution("{product}", product.Description, personalizationIndex);
                    msg.AddSubstitution("{customer}", subscriber.Name, personalizationIndex);
                    personalizationIndex++;
                    
                }

5. Create a test email method, that uses the same logic as your core one, but only sends to one email address. You don’t want to be sending bulk emails out without checking them first!

I hope this new style of thread has been an interesting read, I hope to do more very soon!

It was mentioned in part one that the infrastructure project effectively became a DevOps implementation project, and I’ll try to delve into the bits I can discuss in this post. Firstly there’s the inheritance; over 300 environments, many with specific mods for specific customers, and the remaining with what we call “Extended Solutions” – productized mods effectively. Then there was all the code itself, fortunately, the existing dev team has a fantastic grasp of the deep dark secrets of Git and I have enough of a basic understanding to pick up where others left off, but then, something new to myself came out, and that was the builds of the code. Debug or Release, MSBuild versions, semantic versioning, Git Flow… you get the idea. All very complicated to me at the time, but now it’s in my veins!

Previously the team used an old, unsupported, broken version of Jenkins to build their code, with definitions for each Git Branch, some with bat files, some hardcoded in the Jenkins config screen, basically a mess, and different rules for different people. Well, I like to standardize, so we scrapped the old, and brought in the new. Cue the amazing concept that is Continuous Integration. Having some basic experience with this in Azure DevOps (remember this post?) the concept was not new, however, implementing with Jenkins was a new experience. I managed to inherit a new blank Jenkins server, but first thing I did was reverse proxy via IIS and get it secured with an internal SSL certificate, as well as connect up to the Corporate Active Directory and restrict to our team only, then we got a service account from Corp IT and locked the server down, only myself and Domain Admins can get into the back end, and now we have a secured build server. Why so secure when it’s all internal? Well, that’s because the CTO office allowed us to have the corporate digital cert for code signing so long as it only existed in one, locked-down place. We can call it via the Jenkins application side but not extract, manipulate or otherwise interact with it. With this new updated (and updateable) Jenkins server, plus a couple of useful plugins (Blue Ocean is a must) we have a fantastic platform to manage and analyze our build process. The main feature we are utilizing is the Multibranch Pipelines via Jenkinsfile. This Jenkinsfile is written in groovy and is basically a set of instructions that define a build, for example, we can say build this solution, sign using that certificate and publish the artifacts so we can download afterward. The huge advantage for us is because we build a solution for multiple ERP versions, we can have up to 8 exes output at the end, and we now have one screen to grab them from, regardless of what Git branch we built for. On the subject of Git branches, due to the multibranch pipeline functionality, once our Jenkinsfile is pulled into Master, it will then filter down to all subsequent branches, and with this feature enabled, Jenkins will detect any new branches that were pushed back to the origin with that Jenkinsfile includes. I’ve previously written about VS Code and all the wondrous things it does, but we also discovered a Jenkinsfile checker in the form of https://marketplace.visualstudio.com/items?itemName=janjoerke.jenkins-pipeline-linter-connector. This tool allows us to check syntax, against our own Jenkins server and therefore ensures an accurate rule definition every time we adjust a build. It’s time-savers like these that have boosted the team’s productivity significantly, I recently tweeted about this improvement, as I took hold of an existing codebase and fully integrated it into our new philosophy within an hour or so!

A large part of the battle has been documenting the configuration and the overall process as well as educating colleagues (primarily developers) about how we are using these concepts and tools. I’ve found the majority of developers know the concepts and will have their own experiences with Git and CI/CD but until you document what the process should be in the exact circumstances, they don’t necessarily see the advantages or understand just how powerful these changes are, and more importantly how it improves consistency and productivity across the team. The improvements are already showing for us, and I fully expect that to continue!

Some reference material for a few of the things discussed in the post above:

• Jenkins Multibranch pipelines
• Jenkins behind IIS Reverse Proxy
• Jenkins CI for .Net
• Basic Jenkins for .Net CI
• Git Intro
• Git Flow
• Bitbucket Server (incumbent Git server)
• Sourcetree (preferred Git UI tool)
• Fork (alternate Git UI tool)