aengelsrud

[aengelsrud]

Outcome-Focused Ops: How to Lead When Things Go Wrong

Consider this typical scenario: The upgrade finished on schedule, dashboards were green, the system was up and running, and by midnight, the team started to celebrate a seemingly successful upgrade. Unfortunately, at 2:07 a.m., IT Technical Support tickets spiked on a critical workflow. The workflow had passed cleanly in QA but failed intermittently in production. The root cause turned out to be an edge-case config flag that only triggers at scale, and the test suite never exercised it.

Once in the war room, the team had two options:

🏹 Hunt for who missed it.

🧰 Align on how to fix it.

Thankfully, they chose the second. The team set a goal: restore service, protect data, and reduce the risk of recurrence. Then they made every action serve that desired outcome.

They moved in small, reversible steps to allow for both tracking and visibility of the impact of a single change. The team understood that stacking up too many changes and moving too quickly without thought leads to more inconsistency and vulnerability. Ninety minutes later, stability returned, and by morning, they had a short list of durable improvements to prevent a repeat.

Start with the End State in Mind

When amid these high-stakes situations, pressure scatters attention unless you have a clear goal outcome. You need to start the troubleshooting by defining what “good” looks like. That might be as simple as stating that “resolved” means that the service works, data remains safe, and the risk of recurrence drops measurably. Write that down, say it out loud, make sure everyone agrees to it, and use it to filter every decision.

In your war room, or your Zoom room, make the end state observable. Pin it to the chat or write it on the whiteboard. Then tie that desired end state to concrete signals like success rate, latency, and error budgets so progress is visible in real time. If a task doesn’t move one of those needles, you park it and keep momentum on what does.

Turn the target into a lightweight plan of action that the team can focus on while under stress. Use a Now/Next/Done board, explicit owners, and short time boxes that keep work flowing. Add “stop-the-line” criteria so anyone can pause the plan when indicators say you’re off course. Always keep in mind that blame and who did what have no part in this work; if such conversations arise, it’s important to refocus and set expectations quickly. Drifting off course costs time and missed opportunities to fix the problem.

Run the Work with Accountability (Not Blame)

Blame slows learning and hides information. The focus of an incident, while it is happening, needs to be the resolution, not who is at fault. Accountability speeds learning and gets the right people on the right problem quickly. Name owners, define the following actions, and set the proof you expect when a step completes to keep progress clear.

Prefer small, safe, and reversible changes over big bets you can’t unwind. Treat each action as a hypothesis: state what you expect, run the step, and check the signals before advancing. That rhythm keeps you moving fast without compounding risk.

Protect the humans doing the work. Rotate roles to manage fatigue, pair on risky steps, and invite fast escalation when someone gets stuck. Teams move faster when it’s safe to say, “This doesn’t look right,” and hand off without ego.

Communicate with Cadence and Clarity

Give everyone a single source of truth. Use an easily shareable dashboard that can capture and share actions, next steps, and outcomes.

Share timestamped “Now / Next / Risks” updates so executives and engineers see the same picture. Keep language plain and specific so decisions happen quickly and stay aligned.

Match the message to the audience while keeping facts consistent. Pair a tight exec summary with a slightly deeper technical note that captures owners, timing, and decisions. Close each update by restating the end state and the next two moves to keep your focus sharp.

Set and honor a predictable rhythm. Announce when the next update will land before you end the current one. Cadence reduces anxiety, cuts side-channel noise, and keeps attention on the work that restores stability.

Finish Strong: Turn Stress into Stability

The team members involved, with help from incident management, should close the incident with a short, honest after-action review while details are fresh. Make sure to capture what worked, what didn’t, and what you’ll change next time across people, process, and tooling. It is essential to tie outcomes to MTTD, MTTR, change failure rate, and customer impact so learning sticks.

Focus on converting quick fixes into durable improvements so you don’t miss opportunities found in your failure. You could work to automate manual steps, harden runbooks, or add tests for the exact edge cases that surfaced post-upgrade so you catch the problem in QA next time. Also, tune alerts to see early signals and retire noisy pages that distract from real issues. Too many alerts are sometimes worse than not having the right alerts.

Make the improvements visible and owned. Put them on a prioritized backlog with precise deadlines and success criteria. Reevaluate in a week to confirm implementation of the changes and that the metrics are moving in the right direction.

The Mindset That Wins Under Pressure

You won’t prevent every surprise, especially after significant upgrades. There will be issues. You can choose the response: start blaming each other, get angry and defensive, and work to show that the problem is someone else’s fault, or you can stay positive, define the target state, and focus each step on moving toward it. The first choice only causes more issues, while the second turns a tough night into a better morning for your customers and your team.

Leaders set the tone by modeling calm, clarity, and bias for action. Thank people by name for cross-team help and straight talk, and make it normal to escalate early rather than late. Culture is the force multiplier that carries you through the last 10% when energy dips.

Do this consistently, and challenging efforts stop being setbacks. They become training grounds for stronger teams, tighter trust, and more stable systems. That’s how post-upgrade issues turn into long-term wins.

[aengelsrud]

Rethinking PeopleSoft: Customizing the Right Way: Building on the PeopleSoft Platform, Not Against It

Part 3 of the “Rethinking PeopleSoft” Series

Read part 1 here: Rethinking PeopleSoft: Stop Supporting. Start Enabling: Why It’s Time to Rethink PeopleSoft as a Platform

Read part 2 here: Rethinking PeopleSoft: What Actually Changes When PeopleSoft Becomes a Platform?

Customizations have always been a double-edged sword in PeopleSoft. They can unlock incredible functionality for your organization and have historically been where the true power of PeopleSoft could be found. However, they can also create upgrade nightmares, hidden technical debt, and fragile processes that slow the system down.

Platform thinking changes that. When you start treating PeopleSoft as a platform instead of a monolithic application, you approach customizations differently. You shift from adding code wherever you can to building extensions the right way, with guardrails, visibility, and repeatability.

From Chaos to Composability

In the old application model, customizations were often quick fixes: a SQL tweak here, a hard-coded SQR there, maybe a page modification that someone swore you’d remember in the next upgrade cycle. These changes often lived outside version control, and the knowledge was trapped in the heads of a few admins or developers.

In a platform model, every customization is treated as a component, designed to be portable, modular, and upgrade-safe. You’re no longer hacking the core, you’re building on top of it.

Key platform-friendly tools and patterns include: Drop Zones: Add new fields and components without touching delivered objects. Event Framework: Trigger logic at specific events without hardcoding into the application. Page and Field Configurator: Adjust labels, hide/show fields, and add behavior without modifying delivered pages. Configuration-Driven Development: Where possible, rely on delivered setup tables instead of custom SQL or PeopleCode. These tools aren’t just nice extras. They are your building blocks for safe, upgradeable enhancements. They make it possible to limit or remove customizations all together, while at the same time continuing to deliver high-value, business-specific functionality. On top if that, the features allow you to do that quickly. Guardrails Over Gatekeeping A common mistake is swinging from chaos and customization everywhere to total custmization lockdown. This can turn the platform developement teams into the “no” police. That’s the best part about platform thinking, it’s not about stopping customizations; it’s about enabling safe customizations with clear guardrails.

This approach creates a balance: Guardrails: Code must be versioned, modular, and linked to a deployment pipeline. Extensions should use modern frameworks like Event Mapping or Drop Zones whenever possible. Not Gatekeeping: Developers still have freedom to innovate, but in a structured environment where changes are tracked, reviewed, and automatically tested before hitting production. By shifting the culture from “don’t customize” to “customize the right way,” you empower teams to solve problems without increasing risk. Versioned, Modular, and Safe One of the biggest wins of platform thinking is moving customizations into a version-controlled, modular workflow. That means: All changes live in version control (PeopleCode, SQRs, configurations, DPKs, etc.) Custom code is organized into identifyable PeopleSoft projects Automated pipelines handle builds, deployments, and regression checks This structure gives you rollback options, audit trails, and the confidence to deploy more frequently, because your system is designed for change, not afraid of it.

Here are a few options for PeopleSoft version control: Phire - phireinc.com Quest Stat - www.quest.com/products/… Pivet - github.com/tslater20… The Payoff When you adopt platform-friendly customization practices, you reduce upgrade friction by keeping core code clean, accelerate development by enabling teams to build and deploy safely, and increase system reliability through traceable, testable changes. These practices also unlock composability and reusability, making future projects and upgrades faster and easier. Instead of being viewed as a source of headaches, customizations become strategic enhancements that strengthen and extend the value of your platform.

In the next post, we’ll talk about observability, telemetry, and self-service. These are the tools that make platform operations hum and keep your PeopleSoft environments healthy, fast, and future-ready.

[aengelsrud]

Rethinking PeopleSoft: What Actually Changes When PeopleSoft Becomes a Platform?

Part 2 of the “Rethinking PeopleSoft” Series

In Part 1, we discussed why it’s time to stop treating PeopleSoft as a legacy application and start approaching it as a platform. But let’s get practical. What changes when you make that shift?

This isn’t just about mindset. It impacts how your team operates, the tools you use, what you measure, and how your organization experiences PeopleSoft. Platform thinking reshapes roles, responsibilities, and expectations across the board.

Here’s what that shift looks like in practice.

Reactive Support vs. Proactive Enablement

Traditionally, PeopleSoft support teams have lived in maintenance mode, monitoring uptime, applying patches, troubleshooting outages, and reacting to break/fix issues. This work is essential, but it keeps your team trapped in a reactive cycle where progress only happens after something goes wrong.

Platform teams flip that model. Their focus is on enabling developers, testers, and analysts to move faster and safer by building systems, standards, and services. Instead of spending energy firefighting, they spend energy removing friction and creating reusable solutions that prevent issues before they happen.

Here’s how that shift looks in practice:

Outages: Instead of waiting to respond, platform teams design systems with health checks, automated failover, and monitoring to prevent outages.

Patching: Manual patching becomes automated pipelines that apply updates consistently across all environments.

Environment Refreshes: Rather than one-off requests, refreshes become standardized and often self-service, letting QA or dev teams handle them without tickets.

Monitoring: Basic uptime checks evolve into full observability—dashboards, alerts, logs, and metrics that highlight issues proactively.

User & Developer Support: Tickets and ad hoc requests are replaced with tools, scripts, and documented processes that let teams help themselves safely and efficiently. The result is fewer repetitive tasks, less firefighting, and far more strategic value delivered to the business.

##What a Platform Team Owns This shift also redefines what your team is responsible for. In the application model, ownership is often infrastructure-heavy, encompassing servers, domains, and patches. In the platform model, your team owns:

Infrastructure as Code (Terraform, DPKs)

Automation pipelines (GitLab CI/CD for build/deploy/patch)

Reusable templates and modules (for domain config, app setup, refresh jobs)

Observability and alerting (Prometheus, Grafana, OpenTelemetry, Splunk)

Developer onboarding and tooling (documentation, CLI tools, service APIs)

Service standards (naming conventions, security patterns, versioning rules) You’re no longer just running a system; you’re running a platform product. That requires product thinking, internal customer support, and a clear sense of service ownership.

How This Impacts Your Org Chart and Skills Roadmap

A platform team doesn’t mean you fire all your sysadmins and hire DevOps unicorns. But it does mean you start shifting team roles in ways that align with modern engineering practices:

Traditional sysadmins grow into platform engineers

Manual tasks get automated, freeing time for architecture and tooling

Team members take ownership over services, not just environments (e.g., someone owns Integration Broker, another owns observability, etc.)

Soft skills, like documentation, internal consulting, and cross-functional collaboration, become just as critical as technical depth You also start hiring or training for new skills:

Git and version control workflows

Terraform, Chef/Ansible, and DPKs

REST APIs and integration patterns

Log aggregation, metrics, and trace pipelines

Lightweight scripting to glue systems together The team starts acting like a product team, with a backlog, priorities, and internal users to serve.

Real-World Examples of the Shift

This isn’t theoretical. Here’s what these changes look like when put into action:

🔧 IaC for Environments - Instead of manual PeopleSoft provisioning, you use Terraform + DPK to spin up environments in minutes. It’s version-controlled and repeatable.* 🔁 Service Ownership

One team member becomes the go-to person for IB, monitoring queues, tuning throughput, and maintaining service mappings. Another owns cache tuning and WebLogic health. Everyone owns something.

🛠️ GitOps Workflows

All DPK configuration changes and environment settings are stored in Git. Changes are tested, reviewed, and promoted via GitLab pipelines. You gain traceability and rollback.

🚀 Developer Self-Service Tools - Need to restart an app server? Clear cache? Pull logs? The platform team builds internal CLI tools or scripts to handle these tasks in a safe, audited, and consistent way, so developers and QA don’t have to wait on a ticket.

Final Thought

When PeopleSoft becomes a platform, your team isn’t just keeping systems alive; you’re building the systems that let others thrive. In the next post, we’ll explore how this shift changes the way you handle customizations. Spoiler alert: it’s not about saying “no” to changes, it’s about saying “yes, but here’s the safe, supported way to do it.”

Ready to stop patching and start enabling? You’re halfway there.

[aengelsrud]

Oracle Linux 10 is Here: What You Need to Know

Oracle has officially released Oracle Linux 10 (OL10), marking a significant step forward for enterprise Linux environments. Built as the downstream release of RHEL 10, OL10 is now generally available for x86_64 (x86-64-v3) and ARM aarch64 architectures. On ARM, the Unbreakable Enterprise Kernel (UEK) is the only supported option, while x86 continues to support both UEK and RHCK.

Whether you’re running Oracle Database, PeopleSoft, or cloud‑native applications, this release brings performance boosts, modern security, and a cleaner, more streamlined experience for administrators.

Here’s what stands out.

🚀 Performance and Kernel Options

By default, Oracle Linux 10 installs with UEK 8.1, which is based on Linux 6.12 LTS with selected 6.15 backports for improved hardware and storage performance.

This kernel delivers:

Better NUMA memory handling and I/O scheduling

Improved SSD and NVMe performance

ABI changes that require rebuilding third‑party kernel modules

If your workloads rely on close RHEL compatibility, the Red Hat Compatible Kernel (RHCK) remains available for x86_64 systems, but UEK is the path to the highest performance, especially for Oracle database or middleware workloads.

🛡️ Security and Live Patching

Enterprise security is a central focus in OL10:

Oracle Ksplice continues to allow zero‑downtime kernel and user‑space patching, covering components like OpenSSL and glibc.

Post‑Quantum Cryptography (PQC) support arrives in OpenSSL as a technical preview, preparing for future cryptographic standards.

OpenSSH has new mitigations for side‑channel and credential theft attacks, ensuring safer remote access in modern hybrid environments.

For admins who value uptime, the Ksplice enhancements alone make OL10 a compelling upgrade.

👩‍💻 Modern Developer and Admin Tools

Oracle Linux 10 updates the toolchain for both developers and sysadmins:

GCC with enhanced diagnostics, modern OpenMP, and stronger security flags

Valkey (a Redis-compatible in‑memory store) is now included

.NET 9.0 (new features) and .NET 8.0 LTS for stable enterprise apps

Python 3.12, OpenJDK 21, and CMake 3.30

Updated diagnostic tools like SOS with namespace‑standard plugins and new flags

These updates make OL10 friendlier for building, testing, and running modern workloads across cloud and on‑prem environments.

⚙️ Installer and Infrastructure Improvements

The OL10 installer simplifies setup and supports modern infrastructure out of the box:

Auto‑creation of a sudo‑enabled admin user for faster deployments

Native NVMe‑over‑Fabrics support during installation

GRUB 2.12 with better firmware memory allocation, VLAN and UART support, and TPM fixes

These enhancements make provisioning in cloud and virtualized environments faster and more predictable.

🧹 Cleaning Up: Deprecations and Removals

Oracle Linux 10 also continues the move toward a modernized, leaner OS:

Deprecated: cgroup‑v1, legacy ipset, podman plugins, libvirtd

Removed: cockpit‑composer, SquashFS, runc as default

OpenSSL: ENGINE API and SHA‑1 HMAC in FIPS mode are now deprecated

For sysadmins, this means planning for containerization changes and modern cryptographic policies.

📈 Why This Release Matters

Oracle Linux 10 is not just a version bump. It’s a modern, performance‑tuned, secure platform for enterprises looking to run critical workloads both on‑premises and in the cloud. With Ksplice, UEK 8.1, and updated toolchains, it positions Oracle Linux as a future‑ready OS for databases, middleware, and cloud‑native apps.

If you’re already on OL9, start testing Leapp for in-place upgrades and validate your third-party modules for UEK 8.1 compatibility.

Your Turn: Are you planning to upgrade to Oracle Linux 10 right away, or will you wait for the first minor update? Drop a comment and share how OL10 might fit into your environment!

[aengelsrud]

Stop Supporting. Start Enabling: Why It's Time to Rethink PeopleSoft as a Platform

Part 1 of the “Rethinking PeopleSoft” Series

For years, PeopleSoft has been treated like a classic enterprise application; something you patch, maintain, and try not to break. It sits on its servers (or maybe VMs), it runs business-critical processes, and support means keeping it stable and compliant.

That mindset made sense 10 years ago. But in 2025? It’s time to rethink it. As cloud-native architectures, automation-first strategies, and integrated digital experiences become the norm, the old way of running PeopleSoft is holding teams back. The solution isn’t to rip and replace. It’s to reframe how we think about PeopleSoft, not as an application to support, but as a platform to build on.

From Application to Platform: What’s the Difference?

An application is built to perform a specific task. It has a specific set of features. It’s tightly scoped and user-facing. You maintain it. You support it. You don’t usually build with it.

A platform, on the other hand, is built to enable other things. It’s a foundation. It offers tools, APIs, frameworks, and services that developers and teams use to build, extend, and scale solutions. A platform isn’t just consumed, it’s leveraged.

When you treat PeopleSoft like an application, your mindset is:

“Keep it up. Don’t break it. Patch it when needed.”

When you treat PeopleSoft like a platform, your mindset shifts to:

“How do we enable developers? How do we deliver services that others can build on? How do we make this system part of our enterprise fabric?”

That shift changes everything from your automation strategy to your support model to how you approach customizations.

Why This Shift Matters Now

The world around PeopleSoft has evolved. Most orgs are now running hybrid workloads, building cloud-native apps, and pushing for faster, more flexible delivery models. Yet PeopleSoft often gets stuck in legacy mode, not because it has to, but because of how teams think about it.

In 2025, platform thinking becomes essential for a few key reasons:

Cloud maturity: You’re likely already running workloads in GCP, AWS, or OCI. Treating PeopleSoft as a platform enables you to align it with the same patterns you’re using elsewhere, including IaC, CI/CD, observability, and more.

Automation pressure: Manual patching and environment cloning are time-consuming. Platform teams automate everything. That saves time and increases consistency.

Integration demands: Your enterprise isn’t siloed. HR, Finance, and Student Systems must connect to dozens of other applications. Platforms expose clean APIs, enable secure messaging, and build integration into the architecture, not as an afterthought. What You Gain: Speed, Visibility, Resilience

Reframing PeopleSoft as a platform isn’t just a technical change; it’s a strategic unlock.

You gain:

🔄 Developer velocity: Faster, safer customization using extension patterns (Drop Zones, Event Framework, Configurable Search)

🔍 Observability: Built-in monitoring, tracing, and alerting pipelines using tools like OpenTelemetry and Prometheus

⚙️ Automation: Terraform, Chef, and GitLab pipelines handling patches, refreshes, and even entire environment builds

📦 Scalability: Repeatable platform tooling that works across apps and environments, not just in Prod

This mindset doesn’t just make PeopleSoft better, it makes your team more strategic.

What’s Coming in This Series

This post is just the start. Here’s what’s ahead in the Rethinking PeopleSoft series:

🔧 Part 2: From Maintenance to Enablement

What changes in your team’s responsibilities, mindset, and skill sets when you adopt platform thinking?

🧱 Part 3: Customization Without Chaos

How to safely extend PeopleSoft using modern tools and patterns without setting yourself up for upgrade nightmares.

🗺️ Part 4: Building Your Platform Roadmap

A practical blueprint for turning your team’s vision into an actionable transformation plan.

🎯 Part 5: Sustaining the Shift

How to keep the momentum going, measure success, and build a platform culture that lasts.

If you’ve been treating PeopleSoft like a legacy app, this is your call to stop supporting and start enabling.

It’s time to build the platform your enterprise needs.

[aengelsrud]

Don't Overlook the Gray-Haired Engineer

I’ve seen a trend I don’t love:

✅ A solid resume

✅ 20+ years of experience

✅ Deep infrastructure and system knowledge

❌ Passed over—because of a birthdate.

Here’s the truth: age doesn’t make you irrelevant in the IT industry. It makes you danger-tested. The professionals who’ve been in the field for 20 or 30 years have lived through outages, migrations, security incidents, and leadership changes. They’ve seen what breaks, what lasts, and what actually matters. They don’t panic when something goes down at 2 a.m., and they don’t chase every shiny new tool without understanding the long-term cost. Their experience is hard-won, and it brings a kind of judgment and steadiness that can’t be rushed.

Older IT professionals:

▪️ Have seen five kinds of outages

▪️ Don’t panic under pressure

▪️ Understand trade-offs in ways textbooks never teach

▪️ Mentor others by default

If you’re hiring for a tech role and skipping over someone because they’re 50 or older, you’re not reducing risk; you’re passing on a strategic advantage. Experience doesn’t slow a team down; it anchors it. Seasoned professionals bring steady hands, clear judgment, and the ability to mentor others through complexity. They’ve seen enough to know what matters and how to keep systems running when it counts. Hiring experience isn’t a compromise. It’s an investment in resilience and long-term success.

[aengelsrud]

PeopleTools 8.62: Finally, Centralized Control Over Search Behavior

For years, PeopleSoft administrators have requested a more effective way to manage search. Configuring keyword search, attribute labels, and field settings previously required navigating each component’s CREF individually, an exercise in both tedium and fragility.

PeopleTools 8.62 delivers a fix with the Configurable Search Options page, offering system-wide control over component search behavior from a single interface. It’s a small UI change with significant implications for UX consistency, admin efficiency, and governance.

What Is the Configurable Search Options Page?

It’s a new component available in 8.62 that allows you to manage global search configurations centrally, without editing individual content references. Once configured, these settings override the defaults set at the CREF level (unless a setting is explicitly marked as “Override Not Allowed”).

This means you can apply consistent:

Search Types (e.g., Classic, Keyword, None)

Search Field Labels (user-facing prompts)

Search Attribute Labels (metadata labels)

Search Index Options

Sort order of attributes

Search scope behavior

All of this is set and maintained from one place:

PeopleTools > Portal > Search Framework > Configurable Search Options

Key Features and Benefits

🔹 Unified Experience Across Components: Users receive a consistent search UI and behavior across modules, eliminating confusion over field labels or missing keyword searches in one area but not another.

🔹 Faster Rollouts of Keyword Search: Want to enable keyword search across a module or application? Now you can do it in just a few clicks, without having to chase down over 100 menu items.

🔹 Cleaner Environments: This centralization reduces the risk of misaligned or outdated CREF settings, particularly in development and test environments that are frequently refreshed or cloned.

🔹 Easier to Support and Train: When every component search behaves the same, it’s easier for trainers, help desk staff, and new users to learn and support the system.

Real Use Cases for Configurable Search

Standardizing search for all components used by Student Services across Campus Solutions

Enabling global keyword search for Finance Inquiry pages while hiding unused attributes

Renaming confusing default field labels (like “EmplID”) with terms that end users understand

Aligning sort orders and labels for OpenSearch-based index results across HCM and FSCM

Admin Tips

Overrides are respected: if a component needs different behavior, you can still set it at the CREF level. Index options can be set at the system level, making it easier to fine-tune performance and relevance across your entire search footprint. You can disable configurable search globally for specific components if needed.

Final Thought

The Configurable Search Options page in PeopleTools 8.62 is one of those rare changes that saves time, improves usability, and reduces risk simultaneously. It’s a feature that not only streamlines administration but also improves the PeopleSoft experience across the board.

If you’re managing a large PeopleSoft footprint, this should be one of the first features you adopt in 8.62.

📘 Full Oracle documentation: Working with Configurable Search Page (PeopleTools 8.62)

[aengelsrud]

PeopleTools 8.62: The DynamicLoader Class That's Redefining Fluid Homepage Development

One of the most targeted developer-facing features in PeopleTools 8.62 is the introduction of the PTNUI:Dynamic:DynamicLoader base class. This powerful tool enables the creation of dynamically generated tiles in sectionalized Fluid homepages.

This isn’t a generic PeopleCode loader. It’s a purpose-built framework Oracle added specifically to support Advanced Sectionalized Homepage Development, giving developers fine-grained control over which tiles appear in a section and how they behave, all at runtime.

What It Actually Does

To use DynamicLoader, you create a custom application class that extends it and overrides the LoadSection method. This is where your logic lives: dynamically creating tile objects based on business rules, user data, or any conditional logic that makes sense in your environment.

The class includes several methods that make it easy to build clean, consistent tile experiences without hardcoding every configuration in CREFs or relying on static definitions.

Key Methods in the DynamicLoader Class

CreateTile(node, portal, name, label) - Creates a new tile object for use in the homepage. If the tile name is omitted, one is auto-generated with a DYN prefix.

CreateTileUsingTab(name, label) - Similar to CreateTile, but uses the homepage’s existing tab context for node and portal.

AddTileToSection(tile) - Adds the created tile to the homepage section you’re populating.

GetNextRowNumber() - Ensures the dynamically added tiles appear in order after statically defined tiles.

SetupFluidTarget(tile, url) - Configures the tile’s target to launch a Fluid component or page when selected.

GenerateTileName() / SetTileNamePrefix(prefix) - Helps maintain clean naming conventions for dynamically generated tiles.

LoadSection() - The method you override to define what logic runs to populate a section with dynamic tiles.

Real-World Use Cases

This class unlocks capabilities that PeopleSoft developers have wanted for years:

Show or hide tiles based on user roles, departments, or data values.

Display alerts like “Pending Items,” “Incomplete Tasks,” or “New Messages.”

Build personalized dashboards that don’t require duplicating homepage definitions.

It allows you to treat the homepage like an app, dynamically composing content per user or session instead of just displaying a static grid of tiles.

Final Thought

This is a rare case where Oracle has given PeopleSoft developers true design-time freedom to personalize the UX without bloating the portal registry or building dozens of homepage variants. The DynamicLoader class is a clear step toward more dynamic, personalized, and modern ERP experiences, built using familiar PeopleCode patterns.

If you’re managing user experience in a Fluid-heavy PeopleSoft environment, this is a tool worth learning and leveraging.

📘 Full Oracle Docs – DynamicLoader Class Methods

[aengelsrud]

PeopleTools 8.62 + WebLogic Remote Console: The Middleware Upgrade You Didn't Know You Needed

If you manage a PeopleSoft environment, you know that WebLogic is more than just a “supporting layer.” It’s where the action happens. From deploying domains and configuring managed servers to fine-tuning performance settings and troubleshooting crashes, WebLogic administration is crucial to maintaining PeopleSoft uptime and stability.

That’s why one of the quiet but powerful changes in PeopleTools 8.62 deserves more attention: official support for the Oracle WebLogic Remote Console.

From Legacy to Lightweight: What’s New?

The classic WebLogic Server Administration Console has been showing its age for a while. It’s monolithic, coupled tightly to the domain, and carries a larger-than-necessary attack surface. With WebLogic 14.1.2.0.0, Oracle replaces that model with something smarter: the WebLogic Remote Console.

The WebLogic Remote Console:

Is a standalone desktop application or a hosted web app

Communicates via REST APIs to manage remote domains

Supports read-only and role-based access (RBAC)

Offers a clean, modern UI that loads faster and is easier to navigate

Can work with domain configuration in offline mode using JSON or YAML

PeopleTools 8.62 supports this newer version of WebLogic, and with that, the console is now officially in play for PeopleSoft shops.

Why This Matters for PeopleSoft Admins

You’re likely juggling a mix of responsibilities, including performance tuning, patching, domain management, load balancing, and possibly even automation scripting. The Remote Console doesn’t just look better; it genuinely improves how you manage WebLogic.

Here’s how:

Security and Separation of Duties Traditionally, logging into the WebLogic console required direct access to the server, typically through a browser on an internal jump box. This approach is not ideal in a zero-trust environment. The Remote Console, however, connects through REST endpoints and offers fine-grained access controls. This feature enables a more precise separation of duties, such as providing read-only access to auditors or monitoring teams.

Cloud-Readiness As PeopleSoft environments move toward cloud-hosted VMs and containerized middleware, the Remote Console aligns with this shift. It can manage both online and offline configurations, making it easier to work with Infrastructure-as-Code (IaC) pipelines and container lifecycle tools. You don’t need to shell into containers to view or tweak domain settings.

Performance and Usability The old WebLogic console could be sluggish, especially in large domains. The Remote Console loads faster organizes data more cleanly and includes features like editable property sheets and improved search and navigation tools. For administrators managing multiple environments (dev, test, prod), these improvements significantly reduce friction.

Version Control and Auditing Using offline editing with JSON or YAML configurations means you can version control your WebLogic domain definitions, something that has always been a challenge with GUI-only workflows. This adds traceability to configuration changes and aligns with DevSecOps practices many shops are moving toward.

What to Watch For

Don’t skip setup: You’ll need to enable the RESTful Management Services in WebLogic to use the Remote Console.

RBAC is your friend: Take advantage of the improved security model to enforce proper access levels across teams.

Educate your team: The tool appears differently and functions differently, so you will need to ensure admins understand how to use it effectively.

Final Thought

This shift won’t grab headlines, but for PeopleSoft admins in the trenches, it’s a win. Oracle is investing in modernizing the middleware experience, and PeopleTools 8.62 lays the groundwork for this initiative. Whether you’re on-prem today or moving to OCI or GCP tomorrow, the WebLogic Remote Console is the kind of tool you’ll want to master now before it becomes mandatory later.

Are you already testing it? I’d love to hear about the features you’re using or how you’re integrating them into your PeopleSoft workflows.

[aengelsrud]

📦 PeopleSoft was never designed to be SaaS—but with Oracle Cloud Infrastructure, it’s getting awfully close.

Over the past few months, I’ve talked a lot about how to transform the PeopleSoft experience—making it lighter, faster, and more flexible without giving up the customization that makes it valuable.

From one-click lifecycle management to predictive autoscaling, continuous updates, and built-in analytics, PeopleSoft on OCI isn’t just ERP—it’s a modern, cloud-smart platform.

I put together a quick carousel to show exactly how PeopleSoft delivers SaaS-like value while keeping its enterprise backbone.

👉 Swipe through to see how we’re turning PeopleSoft into something that feels effortless, but still packs all the power.

Let me know what’s resonating—or what you think comes next.

PeopleSoft, SaaS Style

[aengelsrud]

Over eight features, we’ve shown how PeopleSoft sheds its “legacy” label to deliver the simplicity, agility, and innovation enterprises expect from SaaS—without sacrificing its enterprise-grade power.

Transforming PeopleSoft into a SaaS-Like Experience: Series Wrap-Up

[aengelsrud]

SaaS platforms often come with analytics baked-in. PeopleSoft pulls off this trick with PeopleSoft Insights and Real-Time Indexing (RTI) on OCI, turning raw data into actionable intelligence with a SaaS-like flair.

Transforming PeopleSoft into a SaaS-Like Experience: Feature #8

[aengelsrud]

SaaS platforms build trust by incorporating strong security and compliance measures. PeopleSoft on OCI, enhances security with enterprise-grade protections in a similar fashion.

Transforming PeopleSoft into a SaaS-Like Experience: Feature #7

[aengelsrud]

SaaS wins wallets with its predictable, usage-based pricing. On Oracle Cloud Infrastructure (OCI), PeopleSoft emulates this with a cost-efficient model.

Transforming PeopleSoft into a SaaS-Like Experience: Feature #6

[aengelsrud]

SaaS platforms shine by collaborating with other systems. PeopleSoft pulls off this trick with PeopleTools' Integration Broker and OCI’s platform services, turning it into a hub of seamless connectivity and innovation—SaaS-style.

Transforming PeopleSoft into a SaaS-Like Experience: Feature #5

[aengelsrud]

I nearly got fired.

After years of IT success, I stepped into a leadership role outside of my comfort zone—and it nearly wrecked my career. It wasn’t because I didn’t work hard.

The Year That Almost Derailed My Career: What I Learned from Failing in Leadership

[aengelsrud]

Fluid UI offers a sleek, responsive interface that works just like popular SaaS applications, letting employees approve requests or update records from any device.

Transforming PeopleSoft into a SaaS-Like Experience: Feature #4