
The application looks polished, the buttons work, and the demo is going perfectly—until an ordinary user opens the administrator dashboard. This episode explores how small configuration decisions can give people permissions they were never meant to have. We unpack authentication, authorization, roles, and the controls that protect pages, actions, and data. Drawing on Oracle Academy APEX learning, the conversation also examines why applications built with AI assistance still need human review and testing across different user roles.
--------------------------
Transcript:
Congratulations You Just Gave Everyone Admin Access
An Oracle Academy Tech Chat episode in the It Worked on My Page APEX series
Cold Open
Tyra Peirce as narrator: It is demo day. The projector is on. The faculty advisor has found the one chair that squeaks every time anyone breathes.
Lorilyn Owens as developer: Welcome to our new student services portal. You can update your profile, submit a request, and see information relevant to your role.
Tyra Peirce as colleague: Nice. Can I try it?
Lorilyn Owens as developer: Absolutely. I have prepared a test account.
Tyra Peirce as colleague: Huh.
Lorilyn Owens as developer: That is not the sound I wanted.
Tyra Peirce as colleague: I can edit the employee directory.
Lorilyn Owens as developer: That is definitely not supposed to happen.
Tyra Peirce as colleague: I can also change approval statuses.
Lorilyn Owens as developer: Please do not click anything else.
Tyra Peirce as colleague: Too late. I found the admin dashboard. Would you like me to promote myself?
Lorilyn Owens as developer: I would like you to slowly back away from the mouse.
Tyra Peirce: Congratulations. You just gave everyone admin access.
Lorilyn Owens: The page looks polished. The buttons work. The report loads. Then a different user signs in, and your helpful little app becomes a permission-granting golden retriever. It means well. It has no boundaries.
Tyra Peirce: Welcome to Oracle Academy Tech Chat and our special APEX series, It Worked on My Page. Today we are looking at the difference between an app that runs and an app that knows who should be allowed to do what.
Lorilyn Owens: And notice what did not happen in that opening. Nobody guessed a password or broke into the application. The colleague used the account they were given, clicked an ordinary link, and received access the developer never meant to provide. The missing control created the problem.
Lorilyn Owens: We will also talk about AI-assisted development, because an AI tool can help you create an impressive page quickly. It cannot guess your organization's security rules unless you define them, implement them, and test them.
Tyra Peirce: So before anyone promotes themselves during your next demo, let us fix the access model.
A Working Page Is Only the Beginning
Lorilyn Owens: When students build an app, the first milestone is usually visible. The form submits. The chart appears. The search finds the correct record. Those are real accomplishments, and they are satisfying because you can point to them.
Tyra Peirce: Security work is easier to overlook because success often looks like nothing happened. A student tried to open an administrator page and could not. A reviewer could see a request but could not rewrite the student's profile. The system quietly said no in exactly the right place.
Lorilyn Owens: That quiet no is a control working correctly. If the app manages advising requests, club budgets, equipment loans, internship applications, or employee information, different users have different responsibilities. The interface should reflect those responsibilities, and the application must enforce them.
Tyra Peirce: A control is simply a deliberate check that prevents an action the user should not be able to take. The user may be curious, confused, rushing, or clicking a link a teammate sent them. The control should still protect the page, action, or data without depending on perfect behavior.
Tyra Peirce: This is where the phrase It worked on my page becomes dangerous. The developer tested while signed in with a powerful account. Everything worked because that account could do everything. That test proved the feature could run. It did not prove the access design was correct.
Lorilyn Owens: A better question is: what happens when the requester, reviewer, approver, and administrator each sign in? If the answer is exactly the same for all four, your app may have skipped an important design meeting.
Authentication and Authorization
Tyra Peirce: Let us separate two words that are often mixed together. Authentication answers, Who are you? It establishes the user's identity through the application's sign-in method.
Lorilyn Owens: Authorization answers, Now that the application knows who you are, what are you permitted to see and do? Can you open this page? View this report? Edit this record? Approve this request? Manage other users?
Tyra Peirce: Think about a concert. Authentication is presenting a valid ticket at the entrance. Authorization determines whether that ticket is for the balcony, the front row, backstage, or a seat so far away that the singer appears to be a very confident ant.
Lorilyn Owens: A valid ticket does not provide access to every door in the building. In the same way, a successful sign-in should not automatically provide access to every page or action in an application.
Tyra Peirce: And hiding a button is not the same as protecting the action. If the menu does not show an Admin link but the user can still open the page from a saved address, the design has hidden the sign while leaving the door unlocked.
Lorilyn Owens: Oracle APEX authorization schemes can be assigned at several levels, including applications, pages, and page components. That means the app can enforce the rule where the user enters and where the sensitive action occurs.
Tyra Peirce: The learner habit is simple: always ask both questions. Who is signed in, and what should that identity be allowed to do here?
The Helpful Shortcut
Tyra Peirce: Imagine a student team building an internal request app. At first, the only users are the three people building it. Everyone needs to test every page, so everyone receives broad access. That can be reasonable in an early test, but it needs an expiration point.
Lorilyn Owens: Two weeks later, the team adds a faculty reviewer. Then a student employee needs to submit requests. A coordinator needs to approve them. Nobody revisits the original access decision because the deadline is Friday and the presentation template has somehow changed fonts again.
Tyra Peirce: The shortcut did help the first three developers move quickly. The problem began when a temporary testing choice quietly became the production design. Nobody intentionally promoted the new users. The team simply failed to remove an old assignment and replace it with narrower roles.
Lorilyn Owens: The team should name the roles before assigning permissions. A requester creates and views their own requests. A reviewer reads requests assigned to them. An approver records a decision. An administrator manages configuration and access. Your actual roles may differ, but each role should describe a job rather than a favorite person.
Tyra Peirce: That last point matters. A rule such as Jordan can edit everything may work until Jordan graduates, changes jobs, or goes on vacation. A rule such as application administrators can manage access survives changes in the team.
Lorilyn Owens: This is least privilege in practice. Each person receives enough access to complete their work without receiving unrelated power. It reduces accidental changes and makes the app easier to explain, test, and support.
The AI Built Exactly What You Asked For
Tyra Peirce: Now let us give the team an AI assistant. A student types, Create an administration page where users can view, edit, and approve all requests. The assistant helps produce a useful query and a clean page. The student runs it and says, That was unbelievably fast.
Lorilyn Owens: Then the faculty advisor asks, Which users are allowed to open it? The room becomes quiet enough to hear the projector fan reconsidering its career.
Tyra Peirce: The AI did not betray the team. It answered the request it received. The prompt described what the page should do, but it did not describe who should be authorized to do it, which records they should see, or what should happen when access is denied. The generated page may be functional while still missing the authorization scheme the team needs.
Lorilyn Owens: Oracle's APEX documentation warns developers to review and validate AI-generated code because it may contain errors or security risks. That warning gives students a useful professional rule: generated work is a draft that requires human review.
Tyra Peirce: When AI helps create an APEX app, ask it to explain the assumptions it made. Ask which roles the design expects. Ask where authorization must be enforced. Then verify those answers in the application and against approved guidance. A confident explanation is not a security test.
Lorilyn Owens: Also inspect generated SQL and PL/SQL before using it. Confirm which tables and rows the code can reach, how values are supplied, and whether the logic matches the user's role. Do not paste passwords, private records, or other sensitive information into a prompt.
Tyra Peirce: AI can speed up construction. The developer remains responsible for deciding what safe and correct mean in the real application.
How APEX Supports Access Control
Lorilyn Owens: APEX provides several ways to turn the role plan into application behavior. The Access Control feature can establish common roles such as Reader, Contributor, and Administrator. Teams can also define roles that reflect their own workflow.
Tyra Peirce: Accidental access often enters through an ordinary configuration decision. A user keeps a broad testing role. A copied page does not receive the expected authorization scheme. A navigation link is hidden, but the destination page remains open. A process accepts a submitted action because only the button was protected. A report query returns more rows than the role should see.
Tyra Peirce: An authorization scheme expresses a rule the application can evaluate. For example, the rule may ask whether the current user has administration rights. Developers can attach appropriate schemes to navigation entries, pages, buttons, report columns, and other components.
Lorilyn Owens: Protecting the navigation entry improves the experience because users do not see choices they cannot use. Protecting the page matters because users may reach it another way. Protecting the relevant process or component matters because the sensitive action must remain controlled when the page is submitted.
Tyra Peirce: In other words, do not make one lonely menu item carry the entire security plan on its back. It is a menu item. It did not train for this.
Lorilyn Owens: Conditions and authorization schemes also serve different purposes. A condition may control when something renders or processes. An authorization scheme controls access based on the user's privileges. If the requirement is about who is allowed, use the security mechanism designed for that decision.
Tyra Peirce: APEX also includes application-wide security settings and Session State Protection. Session State Protection can help prevent users from changing protected values through manipulated URLs or submitted data. These controls complement authorization; they do not replace a clear role design.
Lorilyn Owens: For a class project, the goal is not to configure every possible enterprise option. The goal is to understand the layers: identity, role, page access, component access, data access, and testing. When one layer grants broader access than intended, another user can inherit power the team never meant to give them.
The Report That Shared Too Much
Tyra Peirce: A second team protects its administration page perfectly. The requester cannot open it, even with a direct link. Everyone celebrates. Then someone opens the ordinary My Requests report and discovers that My apparently means every request submitted since the beginning of time.
Lorilyn Owens: Page access and data access are related, but they are not identical. A user may be allowed to open a report while still being limited to particular rows. A student should see their own requests. A department reviewer may see requests for that department. An administrator may have a broader view.
Tyra Peirce: This is why a report can be authorized correctly and still reveal too much. The page is open to the right audience, but the query or data policy does not limit the records for each role.
Lorilyn Owens: APEX supports row-level data security approaches when an application needs them. The implementation depends on the data model and requirements, so developers should work from a written rule. For example: requesters may view records they created; reviewers may view records assigned to their department.
Tyra Peirce: Notice how testable that sentence is. You can create two requesters, submit different records, and verify that each person sees the expected result. The phrase users should see the right stuff is not nearly as helpful, although it has tremendous potential as a sticky note.
Lorilyn Owens: Access design reaches the data layer. Protect the page, restrict the action, and verify the records returned for each role.
Fixing the Demo Day Surprise
Tyra Peirce: Return to the first demo. A colleague has found the admin dashboard. What should the team do? First, stop the demonstration before anyone changes real information and remove the unnecessary access through the authorized process. Preserve enough detail to understand what happened, but do not turn the room into a live exploration of every exposed feature.
Lorilyn Owens: Next, identify the affected paths. Which accounts received the wrong role? Which pages, components, processes, and data were exposed? Did anyone make a change? The team needs facts before it can say the issue is fixed.
Tyra Peirce: Then correct the role assignments and authorization rules. Do not stop after removing the one link the colleague clicked. Check the page, its sensitive components, its submitted processes, and the rows its queries return. Test the fix using an account that should have access and one that should not.
Lorilyn Owens: The team should document the decision in plain language. For example: only administrators manage role assignments; approvers may update status for requests assigned to their department; requesters may not approve their own submissions.
Tyra Peirce: Finally, decide whether the incident needs to be reported or escalated under the institution's or organization's process. A course project using sample data and a deployed system with real personal information have different consequences. Students should learn to recognize when they need an instructor, system owner, privacy lead, or security professional.
Lorilyn Owens: And no, renaming the admin page Definitely Not Admin does not count as remediation. It does count as a clue for the next person.
Testing Every Role
Tyra Peirce: Before release or demo day, create a small access test. List the roles down one side and the important pages or actions across the top. For each intersection, write allow or deny. That access matrix gives every important capability an expected control instead of relying on memory.
Lorilyn Owens: Then test both outcomes. Confirm that the requester can create a request. Confirm that the same requester cannot approve it. Confirm that a reviewer sees the assigned records. Confirm that a person without administration rights cannot reach the admin page through navigation or a direct address.
Tyra Peirce: Use separate test accounts rather than changing one account repeatedly and hoping you remember which role it has today. Label the accounts clearly. Test with realistic sample data, never with information copied from a real person without authorization.
Lorilyn Owens: If AI generated or revised part of the app, include that work in the same review. Read the code. Inspect the query. Check authorization properties. Ask another team member to test the negative path. The fact that generated code runs without an error does not tell you whether it enforces the intended rule.
Tyra Peirce: A failed negative test is useful. If the student account reaches the admin page, the test has revealed a design gap before launch. Fixing a problem found during testing is normal development, not evidence that the project has failed.
Lorilyn Owens: The best demo includes a quiet success nobody in the audience may notice: each account sees exactly what it needs and nothing extra.
Oracle Academy Curriculum Tie In
Lorilyn Owens: This episode connects directly to the Oracle Academy APEX by providing real world scenarios. It reinforces identity, roles, permissions, authorization, testing, and responsible data use within an application students can build and examine.
Tyra Peirce: For students in computer science, information systems, database, and application development courses, the scenario supports learning about application requirements, database security, systems analysis, internal controls, auditability, and the responsibilities of a developer working with organizational data.
Lorilyn Owens: APEX makes those curriculum concepts visible. Students can translate a written requirement into a user role, an authorization scheme, a protected page, a controlled process, and a test result. That sequence turns a broad instruction such as make it secure into design decisions the team can build, inspect, and explain.
Tyra Peirce: Faculty can use the episode alongside an Oracle Academy APEX lesson before students build by asking them to define users, roles, and allowed actions. After the build, students can review one another's apps for assumptions created by developer accounts, hidden navigation, broad queries, copied pages, or AI-generated code.
Lorilyn Owens: The career lesson is practical. Employers need developers who can build features, explain access decisions, test failure paths, and ask for help when a security question exceeds their authority. Those habits matter whether someone writes every line by hand, uses low code, or works with an AI assistant.
Close
Tyra Peirce: Myth: if a user cannot see the admin button, the admin function is secure.
Lorilyn Owens: Reality: the application must enforce authorization on the page, the action, and the data that require protection. The interface is only one part of that work.
Tyra Peirce: Today's takeaway is to give every powerful page, action, and set of data a clear access rule. Enforce that rule with the appropriate controls, then test the expected yes and the expected no. Sign in as someone else before someone else signs in during your demo.
Lorilyn Owens: And when AI helps build the app, treat its output like work from a very fast new teammate. Review it, test it, and never assume it attended the meeting where your access rules were decided.
Tyra Peirce: Thanks for listening to Oracle Academy Tech Chat and It Worked on My Page. In the next episode, we investigate The Button That Did Absolutely Nothing.
Lorilyn Owens: A button with no action. Just sitting there, looking clickable, contributing nothing. Honestly, we have all been in that group project.
Official Oracle References
Controlling Access with Users and Roles: https://docs.oracle.com/en/database/oracle/apex/26.1/apxdc/controlling-access-users-and-roles.html
Providing Security Through Authorization: https://docs.oracle.com/en/database/oracle/apex/26.1/htmdb/providing-security-through-authorization.html
Preventing URL Tampering: https://docs.oracle.com/en/database/oracle/apex/26.1/htmdb/preventing-url-tampering.html
Using APEX Assistant: https://docs.oracle.com/en/database/oracle/apex/26.1/htmdb/using-apex-assistant.html
Altri episodi di "Oracle Academy Tech Chat"



Non perdere nemmeno un episodio di “Oracle Academy Tech Chat”. Iscriviti all'app gratuita GetPodcast.








