Conti Computer Consulting - CCC

09/02/2026

🚨 YOUR PLATFORM IS NOT FINISHED WHEN YOU LAUNCH IT.

The first version will have:

❌ Confusing workflows
❌ Missing capabilities
❌ Poor documentation
❌ Unhappy developers
❌ Too many tickets

That's normal.

The best platform teams don't ask:

"Did we build the platform?"

They ask:

"Is the platform getting better for developers?"

And they use a continuous feedback loop to make it happen.

Imagine your company launches an Internal Developer Platform.

The architecture looks fantastic.

☸️ Kubernetes
🔄 GitOps
🏗️ IaC
📊 Observability
🔐 Security
🧩 Developer Portal

Everyone celebrates.

Then developers start using it.

And suddenly you hear:

"Why do I need three forms to deploy?"

"Where are the logs?"

"This template doesn't work."

"Why does creating an environment take two days?"

"Can you just do it for me?"

😂

This is where real Platform Engineering begins.

🔁 THE PLATFORM FEEDBACK LOOP

A mature platform continuously moves through:

DEVELOPER NEED
↓
DISCOVER
↓
BUILD
↓
ADOPT
↓
MEASURE
↓
GET FEEDBACK
↓
IMPROVE
↺
BUILD → MEASURE → LEARN → IMPROVE

That's the loop.

1️⃣ 👨‍💻 START WITH DEVELOPER PAIN

Don't start with:

"We should deploy Backstage."

Or:

"We need another Kubernetes tool."

Start with:

"What is making developers slower?"

Examples:

🎫 Too many infrastructure tickets

⏳ Environment creation takes days

🔄 Deployments are inconsistent

🔐 Security requirements are confusing

📊 Developers can't find service health

📚 Documentation is scattered

These are potential platform problems.

2️⃣ 🔍 DISCOVER THE REAL PROBLEM

Talk to developers.

Observe their workflow.

Ask:

"Show me how you deploy an application."

Not:

"What feature do you want?"

Because users often describe the solution they think they need.

Your job is to understand the underlying friction.

3️⃣ 🧩 BUILD THE SMALLEST USEFUL CAPABILITY

Don't build a giant platform on day one.

Suppose developers spend hours creating environments.

Start with:

SELF-SERVICE ENVIRONMENT CREATION

Maybe the first version is simply:

CREATE ENVIRONMENT
↓
SELECT TEMPLATE
↓
PROVISION
↓
READY

That's already valuable.

4️⃣ 🚀 GET REAL USERS ON IT

A platform isn't validated by:

❌ Architecture diagrams

❌ Number of tools

❌ Lines of Terraform

❌ Number of Kubernetes clusters

It's validated by:

Developers actually using it.

Put the capability in front of real teams.

Then watch what happens.

5️⃣ 📊 MEASURE ADOPTION

Don't rely only on:

"People seem to like it."

Measure it.

Useful signals can include:

📈 Platform adoption

👥 Active users

🚀 Deployment frequency

⏱️ Time to first deployment

🎫 Ticket reduction

⚡ Environment provisioning time

❌ Failure rate

🔄 Rework

📚 Documentation searches

The exact metrics depend on your platform.

6️⃣ 💬 COLLECT FEEDBACK

Now ask developers:

"What was painful?"
"What was confusing?"
"What did you expect to happen?"
"What did you have to do manually?"
"What would you change?"

You may discover something surprising.

Your developers don't want:

another dashboard.

They want:

fewer steps.

7️⃣ 🔥 PRIORITIZE THE BIGGEST FRICTION

You will receive dozens of requests.

Don't build everything.

Prioritize based on:

IMPACT × FREQUENCY × EFFORT

For example:

Problem Frequency Impact Priority
Environment creation High High 🔥 High
Better docs High Medium 🟡 Medium
Custom dashboard Low Low 🟢 Low
Manual access requests High High 🔥 High

The goal:

Remove the biggest developer friction first.
8️⃣ 🛠️ IMPROVE THE GOLDEN PATH

Suppose your deployment workflow is:

Git
↓
CI
↓
Security
↓
GitOps
↓
Kubernetes
↓
Observability

But developers keep getting stuck at:

Security configuration.

Don't say:

"Read the documentation."

Ask:

"Can the platform make the secure path easier?"

Maybe the platform provides:

🔐 Secure defaults

📦 Approved templates

🛡️ Policy checks

🔑 Automated secret integration

Now the platform improves.

9️⃣ 📈 MEASURE AGAIN

After the change:

Before:

Environment setup = 2 days

After:

Environment setup = 20 minutes

That's a measurable improvement.

Before:

15 tickets/week

After:

4 tickets/week

Again:

measurable improvement.

🔄 THEN START AGAIN

The loop never really ends.

DEVELOPER
│
▼
NEED / PAIN
│
▼
DISCOVER
│
▼
BUILD
│
▼
ADOPT
│
▼
MEASURE
│
▼
FEEDBACK
│
▼
IMPROVE
│
└──────────────► 🔄

That's the platform product lifecycle.

🚨 THE BIGGEST PLATFORM MISTAKE

Building what engineers think developers need...

without observing what developers actually struggle with.

Example:

Platform Team:

"We built an amazing Kubernetes dashboard!"

Developer:

"I just wanted one-click application deployment."

😅

🧠 PLATFORM ENGINEERING IS A PRODUCT DISCIPLINE

This is one of the biggest mindset shifts.

Traditional infrastructure thinking:

"Does the infrastructure work?"

Platform thinking:

"Can developers successfully use this capability?"

Product thinking:

"Are developers getting enough value from it?"

That's why internal platforms should be treated like products.

🧑‍💻 YOUR DEVELOPERS ARE THE CUSTOMERS

Not paying customers.

But internal customers.

That means you need to understand:

👥 Their workflows

😤 Their frustrations

🎯 Their goals

⏱️ Their time

🧩 Their experience

And continuously improve the product.

📊 WHAT TO MEASURE

A platform dashboard shouldn't only show:

☸️ Cluster CPU

💾 Memory

📦 Pod count

Those matter operationally.

But platform teams should also care about developer experience metrics.

For example:

🚀 TIME TO FIRST DEPLOYMENT

How long does it take a developer to go from:

new service → running service?

🎫 TICKET VOLUME

How many requests require platform-team intervention?

⚡ SELF-SERVICE RATE

What percentage of common workflows can developers complete themselves?

📈 ADOPTION

Are teams actually using the platform?

😤 FRICTION

Where are developers repeatedly getting stuck?

🔥 THE NORTH STAR

A powerful question for a platform team:

"How much unnecessary developer effort did we remove?"

That's more meaningful than:

"How many tools did we deploy?"

🚨 WATCH OUT FOR THE "PLATFORM TAX"

A platform should reduce complexity.

But a poorly designed platform can create another layer:

BEFORE

Developer
↓
Infrastructure
↓
Production

After a bad platform:

Developer
↓
Platform
↓
Platform Ticket
↓
Platform Team
↓
Infrastructure
↓
Production

😬

You didn't create self-service.

You created:

A NEW BOTTLENECK.
🟢 GOOD PLATFORM
Developer
↓
Self-Service
↓
Golden Path
↓
Automation
↓
Production
LESS FRICTION
🔴 BAD PLATFORM
Developer
↓
Portal
↓
Ticket
↓
Approval
↓
Manual Work
↓
Waiting
↓
Production
MORE FRICTION
🧠 PLATFORM SUCCESS FORMULA

Remember:

ADOPTION + EXPERIENCE + OUTCOMES

A platform isn't successful because it exists.

It's successful when it makes engineering better.

🔥 THE FULL LOOP
👨‍💻 DEVELOPER NEED
↓
🔍 DISCOVER
↓
🧩 BUILD
↓
🚀 ADOPT
↓
📊 MEASURE
↓
💬 FEEDBACK
↓
🛠️ IMPROVE
↓
❤️ BETTER EXPERIENCE
↓
📈 MORE ADOPTION
↺

This creates a powerful flywheel:

BETTER EXPERIENCE → MORE ADOPTION → MORE FEEDBACK → BETTER PLATFORM
💬 QUICK TEST

Your platform team built a self-service deployment workflow.

After launch:

Only 15% of developers use it.

What should the team do FIRST?

A️⃣ Force everyone to use it
B️⃣ Build 20 more features
C️⃣ Find out why developers aren't adopting it
D️⃣ Shut down the platform

👇 Comment A, B, C or D.

📌 SAVE + SHARE

📌 Save this Platform Engineering Feedback Loop.

🔄 Share it with someone building an Internal Developer Platform.

👉 Follow Cloud Guru for the next stage of the 60-day journey.

Tomorrow:
🚀 WHAT MAKES A GREAT GOLDEN PATH?

🚀 Linux Foundation Certifications – 30% OFF
💥 Get 30% OFF Linux Foundation Courses & Certifications
COUPON CODE: CLOUDGURU

If you're strengthening the DevOps + SRE + Continuous Delivery foundation behind modern platforms:

🧑‍💻 DevOps and SRE Fundamentals — LFS261

👉 Explore LFS261: https://www.awin1.com/cread.php?awinmid=85919&awinaffid=2797056&ued=https%3A%2F%2Ftraining.linuxfoundation.org%2Ftraining%2Fdevops-and-sre-fundamentals-implementing-continuous-delivery-lfs261%2F

09/01/2026

🚨 MEMORY IS 95% FULL.
IS YOUR SERVER ACTUALLY RUNNING OUT OF MEMORY?

Yesterday:

Disk → 99% full

Today:

Memory → 95% full

And here's where many Linux beginners make a mistake:

"95% memory usage = something is broken."

Not necessarily.

Linux uses memory aggressively for applications, cache and buffers.

So before killing processes or rebooting the server...

INVESTIGATE.

🚨 3:17 AM.

Your monitoring system sends:

🚨 CRITICAL

Memory usage: 95%

You SSH into the server.

What do you run first?

free -h

You might see:

total used free shared buff/cache available
Mem: 16Gi 14Gi 500Mi 200Mi 1.5Gi 1.8Gi
Swap: 4Gi 3.2Gi 800Mi
STOP.

Don't immediately conclude:

"The server has no memory."

Look at:

AVAILABLE
1️⃣ free -h — YOUR FIRST LOOK

Run:

free -h

Pay attention to:

used

Memory currently being used.

buff/cache

Memory Linux is using for buffers and cache.

available

An estimate of memory available for new applications without swapping heavily.

swap

Memory pages moved out of RAM.

🧠 IMPORTANT DISTINCTION

Imagine:

RAM: 16 GB

Used: 14 GB
Available: 1.8 GB

Seeing:

14 GB used

doesn't automatically mean:

"14 GB is permanently consumed by applications."

Some of that memory may be reclaimable cache.

That's why looking only at "used %" can be misleading.
2️⃣ CHECK THE TOP MEMORY CONSUMERS

Now investigate the processes.

ps aux --sort=-%mem | head

You might discover:

USER PID %MEM COMMAND

app 4217 38.4 java -jar app.jar
mysql 2211 18.2 mysqld
root 1842 4.7 nginx

🚨

Now you have something actionable.

The application is consuming:

38.4% of RAM
3️⃣ CHECK LIVE BEHAVIOR

Run:

top

Look at:

%CPU
%MEM
RES
VIRT
Don't just look at the biggest number.

Watch what happens over time.

Is memory:

Stable?

or

Continuously increasing?

That's a completely different situation.

4️⃣ MEMORY LEAK?

Imagine your application behaves like this:

10:00 → 4 GB
11:00 → 5 GB
12:00 → 7 GB
13:00 → 9 GB
14:00 → 12 GB
15:00 → 14 GB

🚨

That's much more concerning than:

10:00 → 14 GB
11:00 → 14 GB
12:00 → 14 GB
13:00 → 14 GB
The trend matters.
5️⃣ CHECK SWAP

Run:

free -h

Look at:

Swap

If the system is heavily swapping, applications may become painfully slow.

You can also investigate:

vmstat 1

Watch the memory and swap activity over time.

6️⃣ CHECK THE OOM KILLER

Linux can kill processes when it cannot satisfy memory requirements.

Look for evidence in the kernel/system logs.

For example:

dmesg | grep -i "out of memory"

or:

journalctl -k | grep -iE "out of memory|oom"

You might discover:

Out of memory: Killed process 4217 (java)
Now you know something important.

The problem isn't simply:

"Memory is high."

You have evidence that:

The kernel experienced memory pressure severe enough to kill a process.

7️⃣ CHECK WHETHER SWAP EXISTS

Run:

swapon --show

You might see:

NAME TYPE SIZE USED
/swapfile file 4G 3.2G

This tells you whether swap is configured and how much is currently being used.

But don't blindly "fix" the problem by adding massive swap.

Swap can help provide a buffer.

It doesn't magically turn insufficient RAM into unlimited RAM.

🧠 THE INVESTIGATION FLOW

Save this:

🚨 MEMORY ALERT
↓
free -h
↓
Check AVAILABLE
↓
ps / top
↓
Find memory consumers
↓
Check the TREND
↓
vmstat
↓
Check swap activity
↓
journalctl / dmesg
↓
Check for OOM events
↓
FIND ROOT CAUSE
↓
FIX + VERIFY
🚨 PRODUCTION CHALLENGE

You run:

free -h

and get:

total used free buff/cache available
Mem: 16Gi 15Gi 300Mi 700Mi 1.6Gi
Swap: 4Gi 3.8Gi 200Mi

Then:

ps aux --sort=-%mem | head

shows:

java 4217 61.2%
mysql 2211 12.4%

What would you investigate first?

A️⃣ Reboot the server
B️⃣ Kill Java immediately
C️⃣ Investigate why the Java process is consuming so much memory and check its trend/logs
D️⃣ Delete /tmp/*

👇 Comment A, B or C.

And tell me WHY.

🧩 BONUS CHALLENGE

Your server reports:

Memory: 95%

But:

available: 5.2Gi
swap: 0
Is the server necessarily in a critical memory situation?

YES or NO?

👇 Explain your reasoning.

💥 THE BIG LESSON
High memory usage ≠ automatically bad.

You need to distinguish:

CACHE
vs
REAL MEMORY PRESSURE
vs
MEMORY LEAK
vs
OOM CONDITION

That's why experienced Linux engineers don't just look at one percentage.

They investigate:

available memory + processes + trends + swap + kernel evidence.

🧠 JUNIOR vs SENIOR
❌ Junior:

"RAM is 95%. Kill something."

🚀 Senior:

"How much memory is actually available?"

Then:

"Which process is consuming it?"

Then:

"Is usage stable or continuously increasing?"

Then:

"Is the system swapping?"

Then:

"Are there OOM events?"

Evidence first.
🎯 WHAT WOULD YOU CHECK?

Imagine you're on-call.

You have:

CPU: 42%
Memory: 95%
Disk: 48%
Swap: HIGH

Which subsystem would you investigate first?

🧠 MEMORY
💾 DISK
⚙️ CPU

👇 Comment your answer.

📌 SAVE THIS

The next time you see:

🔴 MEMORY: 95%

Don't panic.

Don't immediately reboot.

Start with:

free -h
ps aux --sort=-%mem | head
top
vmstat 1
swapon --show
dmesg | grep -i "out of memory"

Then follow the evidence.

🔖 SAVE THIS POST

🔁 SHARE IT with a Linux/DevOps engineer

💬 Answer the production challenge

👥 Follow Cloud Guru

08/30/2026

I can turn on my PC from anywhere. - Read more! 👇

08/30/2026

Linux teams have limited access to some device drivers, leading to false user assumptions - Read more! 👇

08/18/2026

https://angelacontibooks.netlify.app/?fbclid=IwdGRjcATxrsJjbGNrBPGuvXBkb2YFZXh0bgNhZW0CMTEAc3J0YwZhcHBfaWQMMzUwNjg1NTMxNzI4AAEeYCuNoKDW82pIL_bJjcBXAFuZbm0jDVDm3Id5BTkc_c2jdwLQ_4QdY15HUnQ_aem_a0EZzIyh_jeOl3nN9WE-0A

Angela Conti writes slow-burn, emotionally intense romance where the line between love and ruin is never quite clean. Enemies-to-lovers, morally grey protagonists, and endings that cost something to earn.

08/05/2026

https://angelacontibooks.netlify.app

Angela Conti writes slow-burn, emotionally intense romance where the line between love and ruin is never quite clean. Enemies-to-lovers, morally grey protagonists, and endings that cost something to earn.