Minor worked on/working on:

Almost on CV >20hrs :

Spring/Springboot

Goldengate 

Javascript

(REACT 20 hrs, but did not go well enough)

LibreOffice ?

mysql/Sybase/Microsoft SQL Server

Current:

Tiny tech hello world demos of new features.

Working on:

PLSQL http post/JSON get to local Ollama llama3 

- works for small data 

- working on: long data/in chunks/clob rather than varchar2(32767)

(Done:

-Do it in Char rather than Byte so you dont get multibute charcters split in two.

-Have an overlab of 64chars so strippling right whitespace easier.

) 

Next:

AWS/whatever recommended by training advisor 9th july (probably just basic training, fetchcourses.ie is only the most very basic AWS, but has a few Python courses that go beyond very basic.)

(

Recommended. y Advisor: Springboard+ courses - state pays most or all fees.

)

Chatgpt speculation:

(Formatting/web access: beats local emacs .txt file)

Got it — here’s a detailed 4-week, 30-hr/week AWS developer learning plan focused on Java/CLI/bash, including free/cheap resources and practical mini-projects. The schedule balances hands-on coding with reading and watching short videos.

---

4-Week AWS Developer Learning Plan (120 hrs total)

---

Week 1 — Core AWS Developer Fundamentals

Goal: Understand Lambda, API Gateway, DynamoDB basics, Java SDK, CLI tooling, and deploy a simple serverless app.

Day	Topics & Tasks	Resources & Links	Est. Time (hrs)
Mon	Intro to AWS Lambda & Java Runtime- Create your first Lambda function in Java- Explore AWS CLI basics	AWS Docs: Create Lambda with JavaFreeCodeCamp: AWS CLI Basics	6
Tue	API Gateway basics + connect to Lambda- Setup REST API with API Gateway- Test with curl/Postman	AWS Docs: API Gateway REST APIPostman free tier	6
Wed	DynamoDB Introduction- Create tables, put/get items via CLI- Java SDK basics for DynamoDB CRUD	AWS Docs: DynamoDB Developer GuideOfficial AWS SDK for Java v2: DynamoDB	6
Thu	Hands-on: Build & deploy a small “Notes app” (CRUD) using Lambda + API Gateway + DynamoDB- Use SAM CLI to deploy	AWS SAM Docs: Getting startedVideo: AWS SAM Intro (free on YouTube)	6
Fri	Review & Debugging- Use AWS CloudWatch Logs to monitor Lambda- Learn basic IAM roles for Lambda/API Gateway	AWS Docs: CloudWatch LogsAWS IAM Policies Intro (free online tutorials)	6

---

Week 2 — Messaging & Event-driven Architectures

Goal: Build event-driven apps using SQS, SNS, Step Functions; practice local development.

Day	Topics & Tasks	Resources & Links	Est. Time (hrs)
Mon	SQS Fundamentals- Send/receive messages with CLI & Java SDK- Connect SQS to Lambda triggers	AWS Docs: SQS Developer Guide	6
Tue	SNS Basics- Publish/subscribe patterns with CLI & Java- Fanout events to Lambda/SQS	AWS Docs: SNS Developer Guide	6
Wed	AWS Step Functions Intro- Create a simple workflow chaining Lambda functions- Test with sample inputs	AWS Docs: Step Functions Developer GuideFree YouTube tutorials	6
Thu	Logging and Tracing- Enable CloudWatch Logs and X-Ray tracing for Lambdas- Inspect logs and traces to debug	AWS Docs: X-Ray Developer Guide	6
Fri	Local Development Setup- Install and use LocalStack or AWS SAM local mode- Simulate AWS services locally for testing	LocalStack: https://localstack.cloud/SAM Local: https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli.html	6

---

Week 3 — Security & Advanced CLI/SDK Usage

Goal: Master IAM roles/policies, secret management, advanced AWS CLI & Java SDK features.

Day	Topics & Tasks	Resources & Links	Est. Time (hrs)
Mon	IAM Deep Dive- Understand roles, policies, permission boundaries- Practice troubleshooting common permission errors	AWS Docs: IAM User GuideFree course: AWS IAM Fundamentals	6
Tue	Secrets Manager & Parameter Store- Store and retrieve secrets securely in Lambda apps- Use Java SDK and CLI	AWS Docs: Secrets ManagerParameter Store	6
Wed	AWS CLI Mastery- Use multi-profile configs and scripting in Bash- Automate deployments & common workflows	AWS CLI Docs: https://awscli.amazonaws.com/v2/documentation/api/latest/index.htmlBash scripting tutorials	6
Thu	Java SDK Advanced Usage- Async calls, retries, error handling- Integrate with SQS, DynamoDB batch ops	AWS SDK Java v2 docsExample GitHub repos	6
Fri	Project: Secure mini-app using Secrets Manager, IAM, and retry logic- Combine skills learned in a simple app- Write README documentation	Self-directed project with AWS docs and CLI	6

---

Week 4 — Polish, CI/CD & Portfolio Prep

Goal: Build reusable templates, add CI/CD pipelines, and prepare portfolio-ready code.

Day	Topics & Tasks	Resources & Links	Est. Time (hrs)
Mon	Create reusable SAM templates or CLI wrappers- Modularize code for reuse	AWS SAM DocsGitHub repo examples	6
Tue	CI/CD Fundamentals with CodePipeline / GitHub Actions- Simple pipeline to build/deploy Lambda apps	AWS Docs: CodePipelineGitHub Actions: free for public repos	6
Wed	Test automation basics for Lambda functions (JUnit, mocks)	Java testing: JUnit 5Mock AWS SDK: LocalStack	6
Thu	Documentation & README writing best practices	Guides: Write good READMEs	6
Fri	Polish projects, push to GitHub, write portfolio notes- Prepare code snippets and summary for resume/email	Self-directed	6

---

Free & Cheap Resources Summary

• AWS Docs: The best and most up-to-date source (all topics above)

• AWS Free Tier: You can run all these services free within limits (details)

• LocalStack: Local AWS emulator (localstack.cloud, free tier)

• AWS SAM CLI: Free open-source tool for serverless development (SAM Docs)

• YouTube: Channels like "AWS", "freeCodeCamp", "Be A Better Dev" have free tutorials

• A Cloud Guru / Linux Academy: Free trials and free courses on AWS fundamentals

• Postman: Free tier for API testing

• GitHub: Free public repo hosting

---

If you want, I can help you build a simple project template for Week 1 or draft a bash script to automate deployment/testing steps. Would that be helpful?

Absolutely! Here's how you can link your AWS backend (Lambda + API Gateway + DynamoDB) to a simple plain HTML + JavaScript web app with minimal dependencies — no React or big frameworks needed.

---

Linking AWS Backend to a Simple Web App (HTML + Vanilla JS)

---

1. Backend setup recap

• Lambda functions: Your Java/Node.js Lambdas implement the core logic (e.g., CRUD operations).

• API Gateway: Exposes HTTP endpoints that trigger your Lambdas.

• DynamoDB: Stores the data your app works with (e.g., notes, tasks).

---

2. Frontend: Simple HTML + JS boilerplate

A single static HTML page with:

• A simple <form> to submit data (e.g., add a note).

• A <div> or <ul> to display data (e.g., list notes).

• Plain JavaScript for:

  • Handling form submit events

  • Calling your AWS API Gateway endpoint using fetch()

  • Updating the page dynamically

---

3. How it fits together

Step	Description
User loads page	Static HTML + JS loads in browser. No framework needed.
User submits form	JS intercepts submit event, gathers form data.
JS calls API Gateway endpoint	Using fetch(), makes HTTP POST/GET request to your backend API (Lambda behind the scenes).
Lambda processes request	Lambda runs code, e.g., writes data to DynamoDB or fetches data.
Lambda returns JSON	Lambda returns response JSON (e.g., saved note or list of notes).
JS processes response	JS parses JSON, updates DOM to reflect new data or display result.

---

4. Minimal Example (frontend HTML + JS snippet)

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <title>Simple Notes App</title>
</head>
<body>
  <h1>Notes</h1>
  <form id="noteForm">
    <input type="text" id="noteInput" placeholder="Write a note" required />
    <button type="submit">Add Note</button>
  </form>
  <ul id="notesList"></ul>

  <script>
    const apiUrl = 'https://YOUR_API_GATEWAY_ENDPOINT/notes';

    // Handle form submission
    document.getElementById('noteForm').addEventListener('submit', async (e) => {
      e.preventDefault();
      const noteText = document.getElementById('noteInput').value;

      try {
        const response = await fetch(apiUrl, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ note: noteText })
        });
        const data = await response.json();

        if (response.ok) {
          // Append new note to list
          const li = document.createElement('li');
          li.textContent = data.note;
          document.getElementById('notesList').appendChild(li);
          document.getElementById('noteInput').value = '';
        } else {
          alert('Error: ' + data.message);
        }
      } catch (err) {
        alert('Network error: ' + err.message);
      }
    });

    // Optionally: Load existing notes on page load (GET request)
    async function loadNotes() {
      try {
        const response = await fetch(apiUrl);
        const notes = await response.json();
        const list = document.getElementById('notesList');
        notes.forEach(note => {
          const li = document.createElement('li');
          li.textContent = note.text;
          list.appendChild(li);
        });
      } catch (err) {
        console.error('Failed to load notes:', err);
      }
    }

    loadNotes();
  </script>
</body>
</html>

---

5. Things to keep in mind

• CORS: Make sure your API Gateway endpoint enables CORS to allow browser calls from your web page domain.

• Authentication: For a simple app, you might skip it initially, but you can add AWS Cognito or API keys later.

• Error handling: Keep it simple and user-friendly.

• Static hosting: You can host this HTML file anywhere (even just locally) since the backend is remote.

• API Gateway URL: Replace 'https://YOUR_API_GATEWAY_ENDPOINT/notes' with your real API Gateway URL.

---

Summary:

Your Java Lambdas do the heavy lifting on the backend, exposing clean REST endpoints via API Gateway. Your simple HTML + vanilla JS app calls those endpoints with fetch(), sending JSON data and updating the page dynamically — no frameworks or bundlers needed.

If you want, I can help you generate the matching Lambda Java code snippets or SAM template for this example!

Great — if you need authentication but want to keep it simple, here's how you can add authentication to your Java-based AWS backend and connect it to your static HTML+JavaScript frontend.

---

✅ Recommended Setup: Amazon Cognito + API Gateway + Java Lambda + HTML+JS

---

🔐 1. Authentication with Amazon Cognito

Cognito gives you:

• User Pool: Handles user registration, login, password reset, etc.

• Hosted UI (optional): AWS-hosted login form (no need to build it)

• JWT Tokens: Returned to frontend after login

👉 You can integrate Cognito with API Gateway, so only authenticated users can access your endpoints.

---

🌐 2. High-level Flow

[User] ↔ [Frontend: HTML+JS] ↔ [Amazon Cognito Hosted UI (Login)]
     ↘        ↑               ↘
      ↘       |                ↘
   [Gets Token]             [Fetches Data]
        ↓                         ↓
[Include JWT in fetch()] → [API Gateway + Lambda]

---

📋 3. Step-by-step Implementation

A. Set up Cognito User Pool

1. Go to AWS Console → Cognito → Create a User Pool.

2. Enable self-signup (or just allow admin user creation).

3. Enable app client (for your frontend).

4. Note the Pool ID, Client ID, and Domain (for hosted UI).

B. Enable the Hosted UI (for login)

Cognito provides a pre-built login page. Example link:

https://your-domain.auth.REGION.amazoncognito.com/login?client_id=YOUR_CLIENT_ID&response_type=token&scope=email+openid&redirect_uri=https://your-frontend.com

This will:

• Redirect the user to the login page

• After login, redirect them back to your site with a JWT token in the URL fragment

---

C. JavaScript: Extract and use token

On your HTML page (e.g., in <script> block):

function getAccessTokenFromURL() {
  const hash = window.location.hash.substr(1);
  const result = {};
  hash.split('&').forEach(part => {
    const [key, val] = part.split('=');
    result[key] = decodeURIComponent(val);
  });
  return result.id_token || result.access_token;
}

const token = getAccessTokenFromURL();

You then attach this token to your fetch() calls:

const response = await fetch(apiUrl, {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${token}`
  }
});

---

D. API Gateway configuration

1. In API Gateway, go to your resource → Method Request.

2. Enable Cognito Authorizer:

   • Create a new authorizer (type: Cognito).

   • Point it to your User Pool.

3. Attach it to the routes that require login.

4. Deploy your API again.

---

E. Lambda (Java)

Lambda will receive user claims via event.requestContext.authorizer.claims. In Java:

public class Handler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent request, Context context) {
        Map<String, String> claims = (Map<String, String>) request.getRequestContext()
            .getAuthorizer()
            .getClaims();
        String userEmail = claims.get("email");
        
        // your logic here
    }
}

If you're using a framework like Micronaut or Spring Boot in Lambda, you can also access claims via header parsing.

---

🆓 Tools and Resources

Resource	Link
Amazon Cognito	https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html
Hosted UI	https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-userpools-hosted-ui.html
Java Lambda Authorizers	https://docs.aws.amazon.com/lambda/latest/dg/java-handler.html
Simple HTML-JS Cognito Example	Auth0 Blog Sample (conceptual overlap)

---

✅ Result

• User logs in with AWS Cognito

• JavaScript grabs token from URL

• fetch() calls pass the token

• API Gateway authorizes the request

• Lambda receives and processes secure call

---

Would you like a working sample repo or a step-by-step tutorial for the Cognito setup next?

Yes, there can be issues linking from Blogspot or a custom domain to an Amazon Cognito Hosted UI, but they are manageable. Here’s a breakdown:

---

🔒 1. Redirect URI Restrictions in Cognito

Amazon Cognito requires that any redirect_uri (used after login/logout) be:

• Whitelisted in the app client settings

• HTTPS, unless localhost

• Exact match (no wildcards)

✅ What works:

• https://your-blog.blogspot.com

• https://www.yourcustomdomain.com/callback

❌ What fails:

• http:// (non-HTTPS, except for localhost)

• https://*.yourdomain.com (wildcards not allowed)

• Unregistered URLs

---

✅ 2. How to Fix It

A. Add your Blogspot/custom domain to the redirect URIs

Go to:

• Cognito → User Pool → App Clients → Show Details → Hosted UI settings

• Add your full return URI, e.g.:

  • https://your-blog.blogspot.com/callback.html

  • https://login.yourcustomdomain.com/auth

---

🌐 3. HTTPS Requirement on Custom Domains

If you're using a custom domain, ensure:

• HTTPS is working

• The SSL certificate is valid

• You're not redirecting via HTTP or iframe (can cause issues)

---

🧪 4. Testing

From your blog or static site:

<a href="https://your-domain.auth.region.amazoncognito.com/login?response_type=token&client_id=XXX&redirect_uri=https://your-blog.blogspot.com/callback.html">Login</a>

After login, you’ll get:

https://your-blog.blogspot.com/callback.html#access_token=...

Use JavaScript in callback.html to extract and store the token.

---

🔧 Extra: CORS & Security Headers

If you're calling APIs after login:

• Ensure your API Gateway has CORS headers:

  Access-Control-Allow-Origin: *
  

And:

• Avoid embedding the Hosted UI in an iframe — Cognito uses CSP headers that may block it.

---

✅ Summary

Concern	Solution
HTTPS required	Use HTTPS on Blogspot or custom domain
Redirect URI errors	Add full redirect URI to Cognito
CORS problems	Configure CORS in API Gateway
Iframe login	Avoid; use direct link instead

---

Would you like a working example of a Blogspot post linking to a Cognito login with token handling?

Here’s a 10-minute email draft to Killian, summarizing your AWS learning goals for the next month, plus a proposed resume/CV entry update.

---

✉️ Subject: AWS + Java Stack: One-Month Learning Plan + CV Note

---

Dear Killian,

Hope you're well. Just outlining what I’ll be learning over the next 4 weeks — 30 hours/week focused on practical AWS usage with Java, Bash, and CLI. No certs for now — this is project-first, minimal-framework work aimed at usable integration and deployment skills.

---

🔧 Planned AWS Skill Coverage (Aug 2025)

🔐 Authentication

• AWS Cognito login via Hosted UI (OAuth2)

• JWT decoding in JavaScript

• Using tokens to call secured API Gateway endpoints

💡 Compute + API

• Java AWS Lambda (Java 17 .zip/.jar)

• AWS API Gateway REST APIs with Cognito authorizer

• CORS config, CLI deploy, and versioning

🔒 IAM + Secrets

• Secure role-based access with IAM

• Injecting secrets from SSM / Secrets Manager

• Principle of least privilege

🌐 Hosting + Web

• S3 static hosting of HTML/JS frontend

• Auth flow and API calls using pure JS (no frameworks)

🛠️ Tooling + DevOps

• AWS CLI workflows for deploy/logging

• Java SDK for invoking AWS services

• CloudWatch Logs for Lambda debugging

• Basic alerting or metrics

---

⚙️ Extras (Time-Permitting)

• Event triggers via SQS or EventBridge

• DynamoDB simple reads/writes

• Minimal CloudFormation/SAM

---

📄 Updated CV/Resume Entry (proposed)

Independent AWS & Java Developer – Self-Directed Learning (Aug 2025)
Built an authenticated, serverless web application using Java Lambda, AWS Cognito, API Gateway, and S3. Integrated JWT token handling in vanilla JavaScript frontend. Used CLI-based workflows, IAM-secured roles, and parameterized secrets via SSM. Designed for no-framework, minimal-stack deployment.

---

Let me know if you’d recommend any additions — or if you want a code/demo link next month when it’s done.

Best,
[Your Name]

---

Would you like a follow-up email template when you’ve completed the month, with bullet proof of work?

Short answer: Yes, you can do most of that on a low-RAM machine with little Java and some Python, mostly for free — with some important caveats.

---

🔍 Key Factors to Consider:

Factor	Feasibility
Low RAM computer	✅ Mostly okay, especially if you avoid local emulation or heavy IDEs.
Little or no Java	⚠️ Challenging, since much of the course is Java-based — but workarounds exist.
A little Python	✅ Helpful for AWS scripting, automation, or switching away from Java SDK.
Free resources	✅ Most of the plan uses the AWS Free Tier and free tools. Just stay within limits.

---

✅ What will work on a low-RAM machine:

• AWS CLI and SAM CLI — lightweight and run well even with 2–4 GB RAM.

• Basic text editors like VS Code (or even Vim/Nano).

• HTML + Vanilla JS frontend — no frameworks, minimal resources.

• Using AWS Free Tier — if you stay within usage limits.

• Online IDEs (e.g. Replit, GitHub Codespaces, AWS Cloud9's free tier) to avoid local Java installation.

• Python for automation — you can replace some Java SDK parts with boto3.

---

⚠️ What could be hard:

💥 Java SDK Development

• Installing JDK & Maven/Gradle may be heavy on RAM.

• Building and deploying Java Lambda functions can take time and memory.

• Workaround: Use Python or Node.js Lambdas instead (lighter + less boilerplate).

🧪 Local Emulation

• LocalStack or SAM Local emulation can eat RAM fast.

  • These tools run Docker containers. Docker typically needs 4+ GB RAM to run smoothly.

  • Workaround: Test everything live on AWS Free Tier, or use mocking tools / unit tests only.

---

🔄 Reasonable Adjustments to the Plan

✅ Replace Java SDK with Python (boto3):

• Use boto3 in Python to interact with DynamoDB, Lambda, SQS, etc.

• Simpler to learn if you already know some Python.

• Example: Replace a Java Lambda with a Python-based one (you can do this via SAM too).

✅ Use Online Tools:

• AWS Console for visual setup instead of CLI.

• AWS CloudShell: browser-based CLI with no install needed.

• GitHub + Codespaces (free tier): avoids installing Java locally.

---

🛠 Example: Low-RAM Adapted Week 1 Stack

Component	Tool
Lambda	Python runtime (boto3)
API Gateway	Set up in Console or with SAM
DynamoDB	Use Free Tier via Console or boto3
Frontend	Static HTML + Vanilla JS
Deployment	AWS SAM CLI (works if Docker is not needed)
Testing	Postman (or curl)

---

🧰 Recommended Setup for Low-RAM, Minimal Java:

• Use Python Lambdas instead of Java

• Use AWS CloudShell and AWS Console

• Keep everything serverless and small

• Use lightweight text editor (e.g. VS Code or Notepad++)

• Avoid Docker-based local testing — test directly in the cloud

• Use boto3 scripts to explore AWS instead of Java SDK

---

💬 Final Verdict

✅ YES, the entire learning plan can be followed and adapted for your low-RAM, minimal-Java, Python-leaning setup — as long as you:

• Replace Java where possible with Python

• Avoid running Java + Docker locally

• Use AWS Console, Free Tier, and online tools

• Accept that Java-heavy tasks might be skipped or replaced

---

Would you like me to:

• 🔄 Rewrite Week 1 of the plan using Python SDK and lighter tools?

• 🧱 Help you build a simple Python-based Lambda + API Gateway + DynamoDB app?

• 🛠 Draft a boto3 script to do basic DynamoDB CRUD?

Let me know what feels most helpful for your setup.