Category: General

Technically, I am not a fan of this but tired of laughing without facial expressions throughout my career, especially when talking to sales teams. Thanks to ChatGPT, here is the most abused jargons.

1. Edge case
2. Low-hanging fruit
3. Leverage synergies
4. Move the needle
5. Quick win
6. Paradigm shift
7. Boil the ocean
8. Blue-sky thinking
9. Circle back
10. Drill down
11. Push the envelope
12. Scalable solution
13. Out-of-the-box thinking
14. Core competency
15. Pain point
16. Big picture
17. Synergize efforts
18. Strategic alignment
19. Actionable insights
20. MVP (Minimum Viable Product)
21. Ecosystem approach
22. Data-driven decision-making
23. Critical path
24. Hit the ground running
25. Robust architecture
26. Seamless integration
27. Optimize for performance
28. In the weeds
29. Future-proof
30. Stakeholder buy-in
31. Granular level
32. At scale
33. Cross-functional collaboration
34. High-level overview
35. Vertical integration
36. Closing the loop
37. Mission-critical
38. Value proposition
39. Game changer
40. Lean process
41. Disruptive innovation
42. Pain points mitigation
43. Agile mindset
44. Best practices
45. Customer-centric approach
46. Best-in-class
47. Low-risk, high-reward
48. Fail-fast approach
49. Digital transformation
50. Continuous improvement
51. Go-to-market strategy
52. Technical debt
53. Cloud-native architecture
54. Holistic approach
55. Bandwidth constraints
56. Action plan
57. Operationalize the process
58. Right-sizing the solution
59. Minimal footprint
60. Shift left
61. High-touch approach
62. Business as usual (BAU)
63. KPI (Key Performance Indicators)
64. Thought leadership
65. Single source of truth
66. Deliverables alignment
67. Fast-tracking initiatives
68. Technical enablement
69. Customer journey mapping
70. Product-market fit
71. Tipping point
72. Pushing the boundaries
73. Burning platform
74. Clear path forward
75. Closing the gap
76. Data democratization
77. Real-time optimization
78. Heads-down execution
79. Proof of concept (POC)
80. Double down on effort
81. Down the line
82. Capacity planning
83. Bulletproof strategy
84. Architecture runway
85. Ready for primetime
86. Iterate quickly
87. Low-fidelity prototype
88. Growth hacking
89. Agile workflow
90. Full-stack solution
91. Resource constraints
92. Automation at scale
93. Failover mechanism
94. Big data insights
95. Architectural pivot
96. Tech stack enhancement
97. Greenfield development
98. Heavy lifting
99. Blockers and enablers
100. Delivery roadmap

101. Value-added services
102. Time to market
103. Low-hanging opportunities
104. Heavy technical lift
105. Business agility
106. Moving parts
107. Hit capacity
108. Micro-optimization
109. Vertical scalability
110. Horizontal scaling
111. DevOps pipeline
112. Customer pain points
113. Hyperautomation
114. Functional decomposition
115. Lean methodology
116. Resource allocation
117. Feedback loop
118. Plug-and-play
119. Zero-touch automation
120. Feature parity
121. Speed to value
122. Containerization strategy
123. Feature flagging
124. Technical feasibility
125. Seamless migration
126. Decision matrix
127. Frictionless experience
128. Just-in-time (JIT) delivery
129. SLA (Service Level Agreement)
130. Rollback strategy
131. Self-service capabilities
132. Hyper-scale infrastructure
133. Platform agnostic
134. Capacity optimization
135. Risk mitigation plan
136. Digital footprint
137. Shift-right testing
138. Resilient architecture
139. Quicksilver solutions
140. Bottleneck identification
141. Infrastructure as code
142. The North Star metric
143. Plug-in architecture
144. Service orchestration
145. Operational efficiency
146. Customizable framework
147. Proactive monitoring
148. Single pane of glass
149. Empowered teams
150. Decoupled architecture
151. Multi-cloud strategy
152. Intent-based networking
153. Battle-tested solutions
154. Data governance
155. Heuristic approach
156. Data-driven automation
157. Light-touch deployment
158. RACI matrix
159. Edge-to-cloud strategy
160. Enhanced user experience
161. Cloud-agnostic deployment
162. Pushing the roadmap
163. Hyper-personalization
164. Accelerated growth
165. Outcome-based approach
166. Hyper-focused execution
167. Multi-threaded approach
168. In-flight initiatives
169. Strong backlog
170. Low-code/no-code solutions
171. Distributed architecture
172. Decentralized management
173. Decision-making at the edge
174. Shift towards automation
175. Application lifecycle management
176. Full-stack visibility
177. Low-latency applications
178. Blockchain integration
179. Continuous deployment
180. Zero-downtime deployment
181. Stack trace analysis
182. Technical validation
183. Converged infrastructure
184. Architectural refactoring
185. Guardrails for development
186. Next-gen solution
187. Multi-tenant architecture
188. Consumption-based pricing
189. Solution scalability
190. Technical roadmap
191. Fine-tuning processes
192. Zero-day exploits
193. Collaborative tooling
194. Secure-by-design architecture
195. Real-time data ingestion
196. Failsafe mechanisms
197. Pushing to production
198. Cross-pollination of ideas
199. Enterprise-grade solutions
200. Silo-breaking collaboration

201. Mission alignment
202. Architectural governance
203. Problem-solution fit
204. Self-healing systems
205. Industry best practices
206. Continuous integration (CI)
207. DevSecOps practices
208. Scalability roadmap
209. Infrastructure modernization
210. Innovation pipeline
211. Customer-first mindset
212. Digital-first approach
213. Operational resilience
214. Microservices orchestration
215. Security by default
216. Automation-first approach
217. Just-in-time scalability
218. Business continuity planning
219. Lean architecture
220. End-to-end visibility
221. Resource elasticity
222. Self-managed infrastructure
223. Holistic monitoring
224. Technical pivot
225. Shift-left testing
226. Container orchestration
227. Context switching
228. Golden path for developers
229. Cloud-native applications
230. Software-defined infrastructure
231. Autonomous systems
232. Open-source innovation
233. Dynamic provisioning
234. Always-on availability
235. Full-stack observability
236. Right-sizing infrastructure
237. Seamless user onboarding
238. Continuous feedback loop
239. Elastic workload management
240. Test-driven development (TDD)
241. Decentralized control
242. Feedback-driven iteration
243. Hyper-growth phase
244. Automated workflows
245. Proactive governance
246. Modular architecture
247. Collaborative delivery
248. Business impact analysis
249. Go-forward strategy
250. Technical deep dive
251. Dynamic scaling
252. Systems interoperability
253. Thought-partnering
254. Time-boxing
255. Outcome-driven development
256. High-availability systems
257. Data sovereignty
258. Cost optimization strategies
259. Capacity on demand
260. Architecture governance
261. Cloud-first strategy
262. End-to-end automation
263. Infrastructure uplift
264. Latency-sensitive workloads
265. Real-time decision-making
266. Data integrity checks
267. Service-level objectives (SLOs)
268. Governance at scale
269. Throughput optimization
270. Enabling cross-team collaboration
271. Code quality assurance
272. Performance benchmarking
273. Cloud bursting
274. Stateless applications
275. Version control best practices
276. User-centric design
277. Technical enablers
278. On-demand scalability
279. Data lifecycle management
280. Automated scaling
281. Next-gen platforms
282. Continuous performance monitoring
283. Resilience engineering
284. Horizontal infrastructure
285. High-touch services
286. Technical grooming
287. Infrastructure rationalization
288. Resiliency testing
289. Pre-mortem analysis
290. Security-first mindset
291. Operational scalability
292. Converging infrastructure
293. API-first design
294. Autonomous infrastructure
295. Service-level agreements (SLAs)
296. Data-driven architecture
297. Fault-tolerant systems
298. Infrastructure harmonization
299. Pipeline as code
300. Lean thinking for innovation

For the sake of a use case, the intention of this example is to summarize a resume. Google Colab was used for this experiment but you can use your own IDE/environment. Just make sure you have the necessary prerequicites set.

1. Since I am using Google Colab, I will be uploading the sample input file to the “Files” store. You can choose to use your local disk storage if you are on a laptop/pc.
2. While you can use any file format, I am using a pdf file as input so we have to convert the pdf to readable text. I will be using pdfx library to read and extract text data.
3. A meaningful prompt and setting context will be done
4. Access Open API API
5. Receive response and show the summarized text.

Below are the instructions and code:

1. Install Prerequisites

I am using pdfx library to read the pdf document. You can use any provider here.

pip install pdfx

We use OpenAI using LangChain so install the required dependencies

pip install --upgrade langchain langchain-openai tiktoken

2. Load Job Description (JD)

import pdfx
pdf = pdfx.PDFx('sample_data/Sample Resume.pdf')

resume_content = pdf.get_text();

3. Make the resume content compatible for LLM Chain

from langchain.docstore.document import Document
from langchain.text_splitter import CharacterTextSplitter
model_name = "gpt-3.5-turbo"
text_splitter = CharacterTextSplitter.from_tiktoken_encoder(
    model_name=model_name
)

# Caution: This code doesn't bother about large documents so chunking/tokenization is out of scope of this example
texts = text_splitter.split_text(resume_content)

docs = [Document(page_content=t) for t in texts]

4. Initialize OpenAI

from langchain_openai import ChatOpenAI
from google.colab import userdata


# Open AI API key is stored in the Secrets vault in Google Colab
OPENAI_API_KEY = userdata.get('openai_api_key')

llm = ChatOpenAI(
    temperature=0,
    openai_api_key=OPENAI_API_KEY,
    model_name=model_name)

5. Define summarization prompt

from langchain.prompts import PromptTemplate

# Use the prompt "List the skills mentioned in below resume:" to list the skills alone

prompt_template = """Summarize below resume:

{text}

"""

prompt = PromptTemplate(template = prompt_template, input_variables=["text"])

6. Summarization

from langchain.chains.combine_documents.stuff import StuffDocumentsChain
from langchain.chains import LLMChain

llm_chain = LLMChain(llm=llm, prompt=prompt)

#I am ignoring the chunking aspect
chain = StuffDocumentsChain(llm_chain=llm_chain, document_variable_name="text")
summary = chain.run(docs)

7. Print Summary

import textwrap
print(textwrap.fill(summary, width=100))

Example output: <name-removed> is a passionate researcher with a focus on cutting-edge technology such as Machine Learning, Computer Vision, and Deep Learning. He has experience as an Associate Data Scientist-Trainee at Lincode Labs and as an AI/ML Intern. His roles included data collection and cleaning, extending code modules, experimenting and deploying machine/deep learning models, and handling end-to-end processes. He has worked on various projects related to object detection, OCR detection, and classification in the manufacturing domain. <name-removed> has a Bachelor’s degree in Computer Science and skills in Python, machine learning platforms, frameworks, libraries, and tools. He has also worked on academic and personal projects related to border security systems and house price prediction.

Register to attend – https://k-mug.net/events/dotnet-conf-2022-k-mug/